oasislmf.pytools.fm.compute_sparse ================================== .. py:module:: oasislmf.pytools.fm.compute_sparse Attributes ---------- .. autoapisummary:: oasislmf.pytools.fm.compute_sparse.logger Functions --------- .. autoapisummary:: oasislmf.pytools.fm.compute_sparse.get_base_children oasislmf.pytools.fm.compute_sparse.first_time_layer oasislmf.pytools.fm.compute_sparse.first_time_layer_extra oasislmf.pytools.fm.compute_sparse.aggregate_children_extras oasislmf.pytools.fm.compute_sparse.aggregate_children oasislmf.pytools.fm.compute_sparse.set_parent_next_compute oasislmf.pytools.fm.compute_sparse.load_net_value oasislmf.pytools.fm.compute_sparse.compute_event oasislmf.pytools.fm.compute_sparse.init_variable oasislmf.pytools.fm.compute_sparse.reset_variable Module Contents --------------- .. py:data:: logger .. py:function:: get_base_children(node, children, nodes_array, temp_children_queue) fill up temp_children_queue with all the base children of node from index 0 and return the number of base children Args: node: top node children: array of all the children with loss value for each node nodes_array: array of information on all nodes temp_children_queue: empty array where we write base children. Returns: number of base children .. py:function:: first_time_layer(profile_len, base_children_len, temp_children_queue, compute_idx, nodes_array, sidx_indptr, sidx_indexes, loss_indptr, loss_val) first time there is a back allocation with multiple layer, we duplicate loss and extra from layer 1 to the other layers .. py:function:: first_time_layer_extra(profile_len, base_children_len, temp_children_queue, compute_idx, nodes_array, sidx_indptr, sidx_indexes, loss_indptr, loss_val, extras_indptr, extras_val) first time there is a back allocation with multiple layer, we duplicate loss and extra from layer 1 to the other layers .. py:function:: aggregate_children_extras(node, len_children, nodes_array, children, temp_children_queue, compute_idx, temp_node_sidx, sidx_indexes, sidx_indptr, sidx_val, all_sidx, temp_node_loss, loss_indptr, loss_val, temp_node_extras, extras_indptr, extras_val) aggregate the loss and extra of the children of the node that is currently computed Args: node: node that we compute len_children: number of children of the node nodes_array: array of information on all nodes children: array of all the children with loss value for each node temp_children_queue: array storing all the base children of the node compute_idx: single element named array containing all the pointer needed to tract the computation (compute_idx_dtype) temp_node_sidx: dense array to store if sample id has value for this node sidx_indexes: index of sidx for nodes sidx_indptr: : index to sidx pointer sidx_val: sidx values all_sidx: list of all sidx in this computation temp_node_loss: dense array storing the sum of children loss loss_indptr: index to the loss pointer loss_val: loss values temp_node_extras: dense array storing the sum of children extra extras_indptr: index to the extra pointer extras_val: extra values .. py:function:: aggregate_children(node, len_children, nodes_array, children, temp_children_queue, compute_idx, temp_node_sidx, sidx_indexes, sidx_indptr, sidx_val, all_sidx, temp_node_loss, loss_indptr, loss_val) aggregate the loss of the children of the node that is currently computed Args: node: node that we compute len_children: number of children of the node nodes_array: array of information on all nodes children: array of all the children with loss value for each node temp_children_queue: array storing all the base children of the node compute_idx: single element named array containing all the pointer needed to tract the computation (compute_idx_dtype) temp_node_sidx: dense array to store if sample id has value for this node sidx_indexes: index of sidx for nodes sidx_indptr: : index to sidx pointer sidx_val: sidx values all_sidx: list of all sidx in this computation temp_node_loss: dense array storing the sum of children loss loss_indptr: index to the loss pointer loss_val: loss values .. py:function:: set_parent_next_compute(parent_id, child_id, nodes_array, children, computes, compute_idx) Set the parent node that needs to be computed at the next level Args: parent_id: id of the parent child_id: id of the child nodes_array: array of information on all nodes children: array of all the children with loss value for each node computes: array of node that need to be computed. compute_idx: single element named array containing all the pointer needed to tract the computation (compute_idx_dtype) .. py:function:: load_net_value(computes, compute_idx, nodes_array, sidx_indptr, sidx_indexes, loss_indptr, loss_val) .. py:function:: compute_event(compute_info, keep_input_loss, nodes_array, node_parents_array, node_profiles_array, len_array, max_sidx_val, sidx_indexes, sidx_indptr, sidx_val, loss_indptr, loss_val, extras_indptr, extras_val, children, computes, compute_idx, item_parent_i, fm_profile, stepped) compute an entire event, result losses are stored inplace in loss_val Args: compute_info: general information on the computation (financial_structure.compute_info_dtype) keep_input_loss: if true compute the net loss instead of the insured loss nodes_array: array of information on all nodes node_parents_array: array of node to parent node node_profiles_array: array of profile for each node len_array: length of array needed to store loss and extra as dence array max_sidx_val: maximum sidx value sidx_indptr: index to sidx pointer sidx_indexes: index of sidx for nodes sidx_val: sidx values loss_indptr: index of loss for nodes loss_val: loss values extras_indptr: index of extra for nodes extras_val: extra values children: array of all the children with loss value for each node computes: array of node that need to be computed. it is filled up as the computation carries on compute_idx: single element named array containing all the pointer needed to tract the computation (compute_idx_dtype) item_parent_i: each node may have multiple parent that are selected one after another. This array keeps track of which parent index to select fm_profile: array of all the profiles stepped: (True or None) determine if this computation contain stepped profile (using None instead of False to allow jit compilation) .. py:function:: init_variable(compute_info, max_sidx_val, temp_dir, low_memory) extras, loss contains the same index as sidx therefore we can use only sidx_indexes to tract the length of each node values .. py:function:: reset_variable(children, compute_idx, computes) reset the per event array Args: children: array of all the children with loss value for each node compute_idx: single element named array containing all the pointer needed to tract the computation (compute_idx_dtype) computes: array of node to compute