def __init__(self, k):
        Domain.__init__(self)
        self.charge_loss_factor = 0.9
        self.soc_external_losses = -0.05
        self.capacity_min = 0.1
        self.capacity_max = 0.3
        self.soc_min = 0.0
        self.soc_max = 1.0
        self.tau_min = 0.0
        self.tau_max = 1.0
        self.load_min = 0.0
        self.load_max = 1.0
        self.charge_min = 0.0
        self.charge_max = 0.5
        self.load_mean = 0.5
        self.load_std = 0.8

        self.initial_value = 0.0

        # state and action variables
        soc = Variable(self.soc_min, self.soc_max, 0.01) # state of charge
        capacity = Variable(self.capacity_min, self.capacity_max, 0.1) # consumption load
        a_tau = Variable(self.tau_min, self.tau_max, k) # consumption load
        charge = Variable(self.charge_min, self.capacity_max, 0.1) # consumption load

        self.tariff = rt.receive_tariff()

        self.setStateVariables({'soc':soc, 'capacity':capacity}) # define the state variables
        self.setActionVariables({'charge':charge, 'tau':a_tau}) # sets the action variables
        self.current_state = {'capacity':self.capacity_max, 'soc':self.soc_max} # initial state
        self.previous_state = None
        self.new_capacity = self.capacity_max
Exemple #2
0
def main():
    dom = Domain.int_range(0, 11)

    set1 = MutableFuzzySet(dom)
    set1.set(4, 0.2)
    set1.set(6, 0.4)
    set1.set(9, 0.5)

    dom1 = Domain.int_range(-5, 6)
    print(dom1)

    set2 = CalculatedFuzzySet(
        dom1,
        StandardFuzzySets.lambda_function(dom1.index_of_element(-4),
                                          dom1.index_of_element(0),
                                          dom1.index_of_element(4)))

    set3 = CalculatedFuzzySet(
        dom1,
        StandardFuzzySets.l_function(
            dom1.index_of_element(-4),
            dom1.index_of_element(0),
        ))
    Debug.print(set1, "Set1:")
    print(set2.domain)
    Debug.print(set2, "Set2:")
    Debug.print(set3, "Set3:")
Exemple #3
0
    def __init__(self, parent=None):
        super().__init__(parent)

        self.setAttribute(Qt.WA_QuitOnClose)
        self.setAttribute(Qt.WA_DeleteOnClose)

        # create instance variables
        self._ui = uic.loadUi('mainwindow.ui', self)

        # create models
        self._domain = Domain(parent=self)

        self._vcoCharWidget = VCOCharWidget(parent=self)
        self._ui.tabWidgetMain.addTab(self._vcoCharWidget,
                                      'VCO characteristics')

        self._measureModel = MeasureModel(parent=self, domain=self._domain)
        self._markerModel = MarkerModel(parent=self)

        self._plotWidget = PhasePlotWidget(parent=self, domain=self._domain)
        self._ui.layoutPlot = QVBoxLayout()
        self._ui.layoutPlot.addWidget(self._ui.widgetStats)
        self._ui.layoutPlot.addWidget(self._plotWidget)
        self._ui.tabPlot.setLayout(self._ui.layoutPlot)

        # UI hack
        self._show_freq = False
        self._show_amp = False
        self._show_curr = False

        self._init()
Exemple #4
0
    def load_the_domain(self, domain_params):
        if domain_params.get('use_available_domain', None):
            domain = Domain(domain_params['domain_shape'],
                            domain_params['domain_type'],
                            domain_params["domain_number"])

            domain.generate_domain_name()
            stat = domain.load_domain(self.output_folder, domain_params)
            new_agent_loc = domain_params['new_agent_loc']

            if stat:
                print("Using available domain ...")
                return domain
            else:
                print("Domain is not available")

        print("Creating a new random domain ... ")
        domain = create_random_domain(domain_params['domain_shape'],
                                      domain_params['domain_type'],
                                      domain_params['num_wall'],
                                      domain_params['num_storage'],
                                      domain_params['num_gold'],
                                      domain_params["domain_number"])
        # self.save_domain()
        # self.domain.plot_domain(True, self.output_folder)
        # self.new_agent_loc = self.domain_params['new_agent_loc']
        return domain
Exemple #5
0
 def get_parent_domain(self, domain_tag):
     domain = Domain(self.auth, domain_tag)
     domain.cache_list("apps/{0}/domains".format(os.environ['NEST_APP_ID']),
                       None, 'tag')
     if not domain.load():
         print "the domain does not exist"
         return None
     return domain
Exemple #6
0
def main():
    """
    Main function
    """
    domain1: Domain = Domain(43690, 'D1', NUM_MAC_ADDRESSES)
    domain2: Domain = Domain(48059, 'D2', NUM_MAC_ADDRESSES)
    domain3: Domain = Domain(52428, 'D3', NUM_MAC_ADDRESSES)

    for domain in [domain1, domain2, domain3]:
        print(domain)
Exemple #7
0
 def domains(self):
     if not self._domains:
         self._domains = [
             Domain(triple, self.label) for triple in self.triples
         ]
     elif len(self._domains) < len(self.triples):
         # the `geometry` method has computed the first domain already
         self._domains.extend(
             Domain(triple, self.label) for triple in self.triples[1:])
     return self._domains
Exemple #8
0
def split_domain(domain, pos):
    """ Splits a domain into two subdomains. """
    from domain import Domain

    section1 = Domain(name=domain.name + "[:{0}]".format(pos),
                      sequence=domain.sequence[:pos])
    section2 = Domain(name=domain.name + "[{0}:]".format(pos + 1),
                      sequence=domain.sequence[pos:])

    domain.subdomains = [section1, section2]
Exemple #9
0
    def __init__(self, model_type, trajectory, N, nb_games):

        # parameters of the models
        self.trees_n_estimators = 50

        self.model_type = model_type
        self.trajectory = trajectory
        self.nb_games = nb_games
        self.domain = Domain()
        self.model = self.Q_iter(N)
Exemple #10
0
    def equate_coincident_domains(domain1, domain2):
        assert domain1.length == domain2.length

        # Make a new Domain with sequence from both domains
        new_domain = Domain(name="~(" + min(domain1.name, domain2.name) + ")",
                            sequence=domain1.sequence)
        new_domain.restrict_sequence(domain2.sequence)

        # Redirect domain1 and domain2 to point to new domain
        domain1.subdomains = [new_domain]
        domain2.subdomains = [new_domain]
def test_domain_functional(ids):
    """
    Tests instantiation of three test domains:
        -checks number of mac addresses generated per instance
        -checks for uniqueness
    """
    my_domain = Domain(ids, 'Functional Domain Test')

    my_domain.generate_mac_address()
    assert len(my_domain.mac_addresses) == 10
    # use set function to determine uniqueness
    assert len(set(my_domain.mac_addresses)) == 10
Exemple #12
0
	def add_domain(self, init, domain, domains):
		_id = domain['_id']
		if domain['status'] == 'valid' and _id not in self.domains:
			domain = Domain(self, domain)
			if not init:
				domain.load()
			self.domains.put(domain)
		elif domain['status'] == 'invalid' and _id in self.domains:
			tmp = self.domains.pop(_id).domain
			if tmp['last'] < self.last:
				tmp['status'] = 'invalid'
				domains[_id] = tmp
Exemple #13
0
 def add_domain(self, init, domain, domains):
     _id = domain['_id']
     if domain['status'] == 'valid' and _id not in self.domains:
         domain = Domain(self, domain)
         if not init:
             domain.load()
         self.domains.put(domain)
     elif domain['status'] == 'invalid' and _id in self.domains:
         tmp = self.domains.pop(_id).domain
         if tmp['last'] < self.last:
             tmp['status'] = 'invalid'
             domains[_id] = tmp
Exemple #14
0
 def bfs_path(self,
              init_state,
              max_depth=None,
              max_states=None):
     def create_iterator():
         return BreadthFirstIterator2(self,
                                      init_state,
                                      max_depth,
                                      max_states)
     domain = Domain(None, False)
     domain.create_iterator = create_iterator
     return domain
Exemple #15
0
 def __init__(self, id, nr):
     self.domain = Domain()
     self.phrasebase = Phrasebase()
     self.parsing = Parsing()
     self.evaluation = Evaluation(self.domain.getTopics(),
                                  self.domain.getPraise(),
                                  self.domain.getCriticism())
     super(L, self).__init__()
     self.ui = UI(nr)
     self.id = id
     L.totalCount += 1
     self.displayCount()
     self.running = True
Exemple #16
0
def build_trajectory(size, from_action_space=False, action_space=None):
    """
    Build a trajctory of four-tuples using ranfom action
    """
    T= []
    d = Domain()
    x = d.initial_state()
    while len(T) < size:
        if not from_action_space:  # continuous action in (-1,1)
            u = d.random_action()
        else:  # choose an action from a custom discrete action space
            u = np.random.choice(action_space, size=1)

        new_x, r = d.f(u)

        # add the four-tuple to the trajectory
        T.append([x, u, r, new_x, d.is_final_state()])

        if d.is_final_state():
            x = d.initial_state()
        else:
            x = new_x

    # shuffle the trajectory
    np.random.shuffle(T)
    return T
Exemple #17
0
def main(num_lights):

    if num_lights > 10:
        print(f"Warning: there are {num_lights*2**num_lights} possible "
              f"actions to switch on {num_lights} ligths. This will take a "
              f"while...")

    actions = [Switch(num, "ON") for num in range(1, num_lights + 1)]
    actions += [Switch(num, "OFF") for num in range(1, num_lights + 1)]

    lights = Domain(actions)

    print("\nExample on how to switch {} lights on:\n".format(num_lights))

    status = {
        "LIGHT_{}".format(num): "OFF"
        for num in range(1, num_lights + 1)
    }
    goal = {"LIGHT_{}".format(num): "ON" for num in range(1, num_lights + 1)}

    lights.solve(status, goal)

    if num_lights <= 10:
        print("\nOnce all lights are on, plot domain graph and solution")

        labels = {node: node_to_label(node) for node in lights.nodes}

        if num_lights <= 5:
            lights.plot(labels=labels, font_size=9)

        else:
            lights.plot_bokeh(labels=labels, node_size=10)

    print("\nBye")
Exemple #18
0
 def __init__(self):
     Domain.__init__(self)
     self.charge_loss_factor = 0.95
     self.soc_external_losses = -0.03
     self.initial_value = 10.0
     self.max_soc = 0.5
     self.min_soc = 0.0
     self.max_load = 1.0
     self.min_load = 0.0
     self.max_proc = 2.0
     self.min_proc = 0.0
     self.max_tariff, self.base_price, self.pr_coeff, self.pr_im_coeff = 9, 0.22, 0.02, 0.4
     self.imbalance = 0.0
     self.load_mean = 0.0
     self.load_std = 0.1
Exemple #19
0
def endpoint_method(endpoint):
    """The endpoint that drives the dude pipeline"""
    print("get endpoint")
    domain = Domain(endpoint, request)
    importer, driver, transformer = domain.get()

    if not importer.import_request(request):
        return jsonify(importer.errors)

    #print(driver.method(importer.imported))
    #
    # transformer.transform(driver.data)

    # return Response(jsonify(transformer.data()))
    return jsonify(driver.call_method(importer.imported))
Exemple #20
0
def plot_miles(df):
    columns = list(df.columns)
    data = df.to_numpy()
    data = data[:, -1].reshape((-1, 1))

    # data[data==0] = 1
    data[data > 400] = 400
    # data = (np.log10(data) * 10).astype(int)

    temp = int(max(data))

    print('max mile', temp)

    temp_dict = {0: temp + 1}
    domain = Domain(temp_dict, [
        0,
    ])

    hist = tools.get_marginal(data, domain, (0, ))

    hist[hist == 0] = 1
    hist = np.log10(hist)

    ptools.plot_list(hist,
                     './evaluate/trip_miles.pdf',
                     size=(20.0, 2.5),
                     zero_line=True)
Exemple #21
0
def NIST3_read_data(data_path, domain_path):
    print('reading data')
    df = pd.read_csv(data_path)
    df.drop(columns=['trip_day_of_week', 'trip_hour_of_day'], inplace=True)

    by_shift = pd.pivot_table(
        df.assign(n=1),
        values="n",
        index="taxi_id",
        columns="shift",
        aggfunc="count",
        fill_value=0,
    )
    by_pickup = pd.pivot_table(
        df.assign(n=1),
        values="n",
        index="taxi_id",
        columns="pickup_community_area",
        aggfunc="count",
        fill_value=0,
    )
    taxi_df = by_shift.join(by_pickup, rsuffix="p")
    # print(taxi_df.columns)
    # print(taxi_df.index)

    headings = list(df.columns)
    domain_dict = json.load(open(domain_path))
        
    domain_dict = {i: domain_dict[df.columns[i]] for i in range(len(headings))}
    domain = Domain(domain_dict, list(range(len(domain_dict))))


    # print(df.iloc[0:30].to_numpy()[:, [0, 1, 2, 3, 4, -1]])

    return df, domain, headings, taxi_df
    def test_consistent_for_partial_assignment(self):
        # Arrange
        variables = [
            Variable('1', Domain([1, 2, 3])),
            Variable('2', Domain([1, 2]))
        ]
        constraints = [EqualConstraint(variables[0], 2)]
        csp = ConstraintSatisfactionProblem(variables, constraints)
        assignment = Assignment()
        assignment.set(variables[0].name, 2)

        # Act
        consistent = csp.consistent(assignment)

        # Assert
        self.assertTrue(consistent)
Exemple #23
0
def task_2():
    print("Zadatak [2]:\n")

    domains = (Domain((0, 11)), Domain((-5, 6)))
    func = Fuzzy.fuzzy_lambda(domains[1].index(-4), domains[1].index(0),
                              domains[1].index(4))
    sets = (MutableFuzzySet(domains[0]), CalculatedFuzzySet(domains[1], func))
    titles = ("S₁", "S₂ (lambda<-4, 0, 4>(D₂))")

    for i, value in enumerate((1., 0.8, 0.6, 0.4, 0.2)):
        sets[0].set(i, value)

    for t, s in zip(titles, sets):
        print("{}:\n{}\n".format(t, s))

    print("\n")
Exemple #24
0
def main():

    dom = Domain.int_range(0, 11)
    set1 = MutableFuzzySet(dom)
    set1.set(0, 1.0)
    set1.set(1, 0.8)
    set1.set(2, 0.6)
    set1.set(3, 0.4)
    set1.set(4, 0.2)
    Debug.print(set1, "Set1:")

    notset1 = Operations.unary_operation(set1, Operations.zadeh_not())
    Debug.print(notset1, "notSet1:")
    print()

    union = Operations.binary_operation(set1, notset1, Operations.zadeh_or())
    Debug.print(union, "Set1 union notSet1:")
    print()

    intersection = Operations.binary_operation(set1, notset1,
                                               Operations.zadeh_and())
    Debug.print(intersection, "Set1 intersection notSet1:")
    print()

    hinters = Operations.binary_operation(set1, notset1,
                                          Operations.hamacher_t_norm(1.0))
    Debug.print(
        hinters, "Set1 intersection with notSet1 using parameterised"
        " Hamacher T norm with parameter 1.0:")
Exemple #25
0
    def get_domains(self, search=""):
        """Get a list of your :class:`domains <tracker_client.domain.Domain>`.

        Note that the optional search term is supplied as part of the GraphQL query variables and
        affects the API response received, rather than filtering results client-side.

        :param str search: Search term to filter results with. For example, supplying
            the string "abc" would return only Domains containing "abc" in their domain_name.
        :return: A list of your domains.
        :rtype: list[Domain]
        :raises ValueError: if your domains can't be retrieved.
        """
        params = {"after": "", "search": search}
        has_next = True
        domain_list = []

        # The maximum number of domains that can be requested at once is 100
        # This loop gets 100 domains, checks if there are more, and if there are
        # it gets another 100 starting after the last domain it got
        while has_next:
            result = self.execute_query(queries.GET_ALL_DOMAINS, params)

            if "error" in result:
                print("Server error: ", result)
                raise ValueError("Unable to get your domains.")

            for edge in result["findMyDomains"]["edges"]:
                domain_list.append(Domain(self, **edge["node"]))

            has_next = result["findMyDomains"]["pageInfo"]["hasNextPage"]
            params["after"] = result["findMyDomains"]["pageInfo"]["endCursor"]

        return domain_list
Exemple #26
0
 def test_contructor_num_mac(self):
     """
     Test if contructed with the right number of mac addresses
     """
     for num_mac_addresses in range(3):
         domain = Domain(1, 'test', num_mac_addresses)
         self.assertEqual(len(domain.mac_addresses), num_mac_addresses)
Exemple #27
0
    def __init__(self, *args, **kargs):
        """
    Initializes a new Strand object.  The following keyword arguments are
    accepted: name, domains OR sequence.
    
    If direct sequence constraints are specified, a new domain is defined
    with these constraints, and is assigned as the domain list for this
    Strand.
    """

        # Assign id
        self.id = Strand.id_counter
        Strand.id_counter += 1

        # Assign DNA object type
        self._object_type = 'strand'

        # Assign name
        if 'name' in kargs: self.name = kargs['name']
        else: self.name = 'strand_{0}'.format(self.id)

        # If sequence constraints were specified, create a dummy domain with
        # these constraints. Otherwise, assign the given list of domains.
        if 'domains' in kargs and 'sequence' not in kargs:
            self._domains = kargs['domains']
        elif 'sequence' in kargs and 'domains' not in kargs:
            d = Domain(name=self.name + "_domain", sequence=kargs['sequence'])
            self._domains = [d]
        else:
            raise ValueError("Must specify strand constraints or domain list.")

        # Assign length
        self._length = sum([d.length for d in self._domains])
Exemple #28
0
    def composition_of_binary_relations(r1, r2):
        dom1 = r1.get_domain()
        dom2 = r2.get_domain()
        size1_x = dom1.get_component(0).get_cardinality()
        size1_y = dom1.get_component(1).get_cardinality()
        size2_x = dom2.get_component(0).get_cardinality()
        size2_y = dom2.get_component(1).get_cardinality()
        if size1_x != size2_y:
            raise DomainsDimensionError(
                "Invalid domain dimensions for composition.")
        rows = [[
            r1.get_value_at(dom1.element_for_index(j + i * size1_y))
            for j in range(size1_y)
        ] for i in range(size1_x)]
        columns = [[
            r2.get_value_at(dom2.element_for_index(i + j * size2_y))
            for j in range(size2_x)
        ] for i in range(size2_y)]

        new_domain = Domain.combine(dom1.get_component(0),
                                    dom2.get_component(1))
        new_fset = MutableFuzzySet(new_domain)
        for i, elem in enumerate(new_domain):
            mins = [
                min(x, y)
                for x, y in zip(rows[i // size1_x], columns[i % size2_y])
            ]
            new_fset.set(elem, max(mins))
        return new_fset
Exemple #29
0
    def _domainListCheck(self):
        newList = self._getMessagesForDomainListing('add')
        adds, removes = splitDictLists(newList, self._domainListMessages,
                                       RH_Message().keys())

        # Removals
        ids = [r['rhid'] for r in removes]
        indices = []
        if (0 < len(ids)):
            for i, d in enumerate(self._domains):
                if (d.getID in ids):
                    d.cleanUp()
                    indices.append(i)
            self._domains = [
                d for i, d in enumerate(self._domains) if i not in indices
            ]

        # Additions
        for a in adds:
            self._domains.append(
                Domain(
                    redhawk.attach(
                        a['rhname']),  # Return redhawk domain instance
                    '',  # No parent ID
                    self.outbox))  # Using the global outbox

        self._domainListMessages = newList
        self.domainTask = gevent.spawn_later(self._domainTaskWaitSec,
                                             self._domainListCheck)
Exemple #30
0
    def from_conf(conf, init_fields=True, init_variables=True, init_equations=True, init_solvers=True):

        mesh = Mesh.from_file(conf.filename_mesh)

        eldesc_dir = op.join(install_dir, "eldesc")
        domain = Domain.from_mesh(mesh, eldesc_dir)
        domain.setup_groups()
        domain.fix_element_orientation()
        domain.setup_neighbour_lists()

        obj = ProblemDefinition(conf=conf, domain=domain, eldesc_dir=eldesc_dir)

        # Default output file trunk and format.
        obj.ofn_trunk = io.get_trunk(conf.filename_mesh)
        obj.output_format = "vtk"

        obj.set_regions(conf.regions, conf.materials, conf.funmod)

        if init_fields:
            obj.set_fields(conf.fields)

            if init_variables:
                obj.set_variables(conf.variables)

                if init_equations:
                    obj.set_equations(conf.equations)

        if init_solvers:
            obj.set_solvers(conf.solvers, conf.options)

        obj.ts = None

        return obj
Exemple #31
0
    def test_solver_success_many_variables_many_constraints(self):
        # Arrange
        variables = []
        domain = set([1, 2, 3, 4, 5])
        for i in range(5):
            variable = Variable(str(i), Domain(list(domain)))
            variables.append(variable)
        constraints = [
            EqualConstraint(variables[2], 3),
            AllDiffConstraint(variables)
        ]
        csp = ConstraintSatisfactionProblem(variables, constraints)
        solver = Solver()

        # Act
        result = solver.solve(csp)

        # Assert
        self.assertTrue(result.success)
        assignment = result.assignment
        self.assertIsNotNone(assignment)
        self.assertEqual(3, assignment.get(variables[2].name))
        encountered_values = set()
        for variable in variables:
            value = assignment.get(variable.name)
            self.assertTrue(value in domain)
            self.assertFalse(value in encountered_values)
            encountered_values.add(value)
Exemple #32
0
def test_public_score():
    # df_2018 = pd.read_csv('./data/2018data_final/2018.csv')
    # df_public = pd.read_csv('./data/ground_truth.csv')
    # df_public = pd.read_csv('./data/2020data_final/2020.csv')
    # df_public = pd.read_csv('./data/2014data_final/2014.csv')
    # df_public = pd.read_csv('./data/2018data_final/2018.csv')
    df_public = pd.read_csv('./data/2017data_final/2017.csv')

    # for attr in ['taxi_id', 'trip_day_of_week', 'trip_hour_of_day']:
    for attr in ['trip_day_of_week', 'trip_hour_of_day']:
        # df_2018 = df_2018.drop(columns=attr)
        df_public = df_public.drop(columns=attr)

    # data_2018 = df_2018.to_numpy()
    data_public = df_public.to_numpy(dtype=int)
    for attr in range(data_public.shape[1]):
        print(attr, np.unique(data_public[:, attr]))

    # print(df_2018.columns)
    # print(df_public.columns)

    domain_dict = json.load(open('./preprocess/domain.json', 'r'))
    domain_dict = {
        i: domain_dict[df_public.columns[i]]
        for i in range(len(df_public.columns))
    }
    domain = Domain(domain_dict, list(range(len(domain_dict))))
    print(domain)

    df_public = df_public.assign(epsilon=10.0)
    df_public.to_csv('./submission_2017.csv', index=False)
    def test_not_consistent_if_assignment_violates_constraint(self):
        # Arrange
        variables = [
            Variable('1', Domain([1, 2, 3])),
            Variable('2', Domain([1, 2]))
        ]
        constraints = [EqualConstraint(variables[0], 2)]
        csp = ConstraintSatisfactionProblem(variables, constraints)
        assignment = Assignment()
        assignment.set(variables[0].name, 3)

        # Act
        consistent = csp.consistent(assignment)

        # Assert
        self.assertFalse(consistent)
Exemple #34
0
    def index(self, **dom):
        '''
        Returns indexes given domain
        '''
        dd = self.domain
        dd.update(dom)

        return Domain(**dd)(self.grid, self.time)
Exemple #35
0
def process_calc(bAuthenticate):
    # connect to MongoDB
    client = MongoClient()
    db = client[database]
    # DB authentication if required
    if bAuthenticate:
        bLoggedIn = db.authenticate(username, password, source=source_database)
    else:
        bLoggedIn = True
    if bLoggedIn:
        logger.info("Authenticated")
        pd = db.Project.find_one({"project_code":"MFW001_0-010 Metro Paris-Ligne 15_T2A"})
        if pd:
            logger.info("Project %s found", pd["project_name"])
            p = Project(db, pd)
            p.load()
            found_domains = Domain.find(db, {"project_id": p._id})
            for dom in found_domains:
                d = Domain(db, dom)
                d.load()
                asets = db.AlignmentSet.find({"domain_id": d._id})
                for aset in asets:
                    a_set = AlignmentSet(db, aset)
                    a_set.load()
                    #sCode = a_set.item["code"]
                    als = Alignment.find(db, {"alignment_set_id":a_set._id}).sort("PK", 1)
                    cnt = 0.
                    cnt_tot = als.count()
                    for al in als:
                        a = Alignment(db, al)
                        a.setProject(p.item)
                        a.load()
                        cnt+=1.
                        
                        sys.stdout.write("\r{:5s} pk= {:.0f} progress= {:.0%}".format(a_set.item["code"], a.item["PK"], cnt/cnt_tot ))
                        sys.stdout.flush()
                        a.perform_calc(str(datetime.now()))
                        
    else:
        logger.error("Authentication failed")
Exemple #36
0
class AcheDashboard(object):

    def __init__(self, crawl):
        self.crawl = crawl
        if self.crawl.crawler != "ache":
            raise ValueError("Crawl must be using the Ache crawler.")
        self.harvest = Harvest(crawl)
        self.domain = Domain(crawl)

    def get_harvest_plot(self):
        # TODO: Remove Pokemon exception catching
        try:
            script, div = self.harvest.create()
        except:
            return [None, None]
        return [script, div]

    def get_domain_plot(self):
        # TODO: Remove Pokemon exception catching
        try:
            script, div = self.domain.create()
        except Exception:
            return [None, None]
        return [script, div]

    def get_relevant_seeds(self):
        # Converts string to StringIO to allow pandas to read it as a file
        seeds = pd.read_csv(StringIO(self.domain.get_relevant_data()),
                           delimiter='\t', header=None,
                           names=['url', 'timestamp'])
        return seeds['url'].to_dict().values()

    def get_plots(self):
        harvest_plot = self.get_harvest_plot()
        domain_plot = self.get_domain_plot()
        return {
            'scripts': [domain_plot[0], harvest_plot[0]],
            'divs': [domain_plot[1], harvest_plot[1]],
        }
Exemple #37
0
def create_vm(args, connection):
    domains = get_domains(connection)
    if args.new_vm_name in domains.keys():
        print ("Virtual machine \"" + args.vm_name + " already created.")
    else:
        domain = Domain(args.new_vm_name, args.memory, args.uuid, args.vcpu,
                        args.os_type, args.type_arch, args.type_machine,
                        args.clock_offset, args.domain_type,
                        args.emulator)
        if args.disks is not None:
            for disk in args.disks:
                domain.add_disk(disk, "disk")
        if args.cdroms is not None:
            for cdrom in args.cdroms:
                domain.add_disk(cdrom, "cdrom")
        if args.nets is not None:
            for net in args.nets:
                domain.add_network(net_name=net)
        if args.bridges is not None:
            for br in args.bridges:
                domain.add_network(net_type="bridge", net_name=br)

        print ("Try to create \"" + domain.name + "\"")
        connection.defineXML(xml_to_string(domain.get_xml()))
def back_tracking(letters, debug, value_heuristic="no", most_variable="no", fwck=0):
    dictionary, frequecy_list = Input.get_source()

    if value_heuristic == "better_greedy" or value_heuristic == "more_better":
        frequecy_list = Input.get_new_frequency_list('new_freq_list')

    assignment = Assignment(letters, 3)
    constraints = Constraint(3)
    csp = Csp(dictionary, frequecy_list, constraints)

    csp.debug = debug
    csp.value_heuristic = value_heuristic
    csp.most_variable = most_variable
    csp.fwck = fwck
    domain = Domain.get_default_domain(3)

    return back_track(assignment, csp, domain)
Exemple #39
0
    def __init__(self):
        self.document = Document()
        self.session = Session()
        self.session.use_doc('crawler_dashboard')
        self.session.load_document(self.document)

        #self.harvest_source = ColumnDataSource(data=dict())
        #self.domain_relevant_source = ColumnDataSource(data=dict())
        #self.domain_crawled_source = ColumnDataSource(data=dict())
        #self.domain_frontier_source = ColumnDataSource(data=dict())
        #self.handson_source = ColumnDataSource(data=dict())
        #self.termite_source = ColumnDataSource(data=dict())

        self.harvest = Harvest()
        self.domain = Domain()
        #handson = Handson()
        self.termite = Termite()

        self.document.add(self.create_layout())
        self.session.store_document(self.document)
Exemple #40
0
    def __init__(self, path, url):
        self.document = Document()
        self.session = Session(name=url, root_url=url)
        #self.session = Session('load_from_config=False')
        self.session.use_doc('crawler_dashboard')
        self.session.load_document(self.document)

        #self.harvest_source = ColumnDataSource(data=dict())
        #self.domain_relevant_source = ColumnDataSource(data=dict())
        #self.domain_crawled_source = ColumnDataSource(data=dict())
        #self.domain_frontier_source = ColumnDataSource(data=dict())
        #self.handson_source = ColumnDataSource(data=dict())
        #self.termite_source = ColumnDataSource(data=dict())
        self.harvest = Harvest(path)
        self.domain = Domain(path)
        #handson = Handson()
        #self.termite = Termite()

        self.document.add(self.create_layout())
        self.session.store_document(self.document)
Exemple #41
0
class DashBoard(object):

    def __init__(self):
        self.document = Document()
        self.session = Session()
        self.session.use_doc('crawler_dashboard')
        self.session.load_document(self.document)

        #self.harvest_source = ColumnDataSource(data=dict())
        #self.domain_relevant_source = ColumnDataSource(data=dict())
        #self.domain_crawled_source = ColumnDataSource(data=dict())
        #self.domain_frontier_source = ColumnDataSource(data=dict())
        #self.handson_source = ColumnDataSource(data=dict())
        #self.termite_source = ColumnDataSource(data=dict())

        self.harvest = Harvest()
        self.domain = Domain()
        #handson = Handson()
        self.termite = Termite()

        self.document.add(self.create_layout())
        self.session.store_document(self.document)

    def render(self):
        self.create_layout()
        self.document.add(self.layout)
        self.update_data()

    def create_layout(self):

        #button = Button(label="Randomize data", type="success")
        #button.on_click(update_data)
        #top_panel = HBox(children=[button, self.harvest.plot, self.harvest.rate_plot])
        top_panel = HBox(children=[self.harvest.plot, self.harvest.rate_plot])
        domains = VBox(children=[self.domain.sort_relevant_plot, self.domain.sort_crawled_plot, self.domain.sort_frontier_plot], width=200)   
        #middle_panel = HBox(children=[domains, handson.plot])
        middle_panel = HBox(children=[domains])
        layout = VBox(children=[top_panel, middle_panel, self.termite.plot])
        self.layout = layout
        return layout

    def update_data(self):

        self.harvest.source = self.harvest.update_source()
        self.domain.sort_relevant_source, self.domain.sort_crawled_source, self.domain.sort_frontier_source = self.domain.update_source()
        self.termite.data, self.termite.source = self.termite.update_source()
        #self.session.store_objects(ds)
        self.session.store_document(self.document)

        
    def run(self, poll_interval=0.5):
        #link = self.session.object_link(self.document.context)
        #print("Please visit %s to see the plots (press ctrl-C to exit)" % link)

        try:
            while True:
                self.update_data()
                self.session.load_document(self.document)
                time.sleep(poll_interval)
        except KeyboardInterrupt:
            print()
        except ConnectionError:
            print("Connection to bokeh-server was terminated")
Exemple #42
0
 def testChooseInitializer_Integer(self):
   domain = Domain(type=Domain.WHOLE_NUMBER, low=Integer(20), high=Integer(40))
   initializer = domain.chooseInitializer()
   self.assertTrue(initializer.is_integer)
   self.assertTrue(initializer >= domain.low)
   self.assertTrue(initializer <= domain.high)
Exemple #43
0
 def __init__(self, crawl):
     self.crawl = crawl
     if self.crawl.crawler != "ache":
         raise ValueError("Crawl must be using the Ache crawler.")
     self.harvest = Harvest(crawl)
     self.domain = Domain(crawl)
Exemple #44
0
    def get_domain(self, domain_name, authentication_token):

        return Domain.from_existing(domain_name, authentication_token)
Exemple #45
0
def plot_data(bAuthenticate, sPath):
    # connect to MongoDB
    client = MongoClient()
    db = client[database]
    ##################################################### GIS SETUP
    driver = ogr.GetDriverByName("ESRI Shapefile")
    # create the spatial reference, EPSG3949 RGF93 / CC49 - http://spatialreference.org/ref/epsg/3949/
    # xMin,yMin 1653513.80,8175914.21 : xMax,yMax 1659996.62,8177877.58
    srs = osr.SpatialReference()
    srs.ImportFromEPSG(3949)
    
    
    # DB authentication if required
    if bAuthenticate:
        bLoggedIn = db.authenticate(username,password,source=source_database)
    else:
        bLoggedIn = True
    if bLoggedIn:
        logger.info("Logged in")
        pd = db.Project.find_one({"project_code":"MFW001_0-010 Metro Paris-Ligne 15_T2A"})
        if pd:
            logger.info("Project %s found" % pd["project_name"])
            p = Project(db, pd)
            p.load()
            found_domains = Domain.find(db, {"project_id": p._id})
            for dom in found_domains:
                d = Domain(db,dom)
                d.load()
                # Example of query
                # asets = db.AlignmentSet.find({"$and":[{"domain_id": d._id},{"code": "main_01"}]})
                asets = db.AlignmentSet.find({"$and":[{"domain_id": d._id}]})
                for aset in asets:
                    a_set = AlignmentSet(db,aset)
                    a_set.load()
                    sCode = a_set.item["code"]
                    
                    # GIS create the data source
                    shpfname=os.path.join(sPath,"gis","smt_%s.shp" % sCode)
                    if os.path.exists(shpfname):
                        os.remove(shpfname)
                    data_source = driver.CreateDataSource(shpfname)
                    layer = data_source.CreateLayer("subsidence", srs, ogr.wkbPoint)     
                    # Add the GIS fields we're interested in
                    field_name = ogr.FieldDefn("Name", ogr.OFTString)
                    field_name.SetWidth(24)
                    layer.CreateField(field_name)
                    field_type = ogr.FieldDefn("Type", ogr.OFTString)
                    field_type.SetWidth(24)
                    layer.CreateField(field_type)
                    field_align = ogr.FieldDefn("Alignment", ogr.OFTString)
                    field_align.SetWidth(24)
                    layer.CreateField(field_align)
                    layer.CreateField(ogr.FieldDefn("PK", ogr.OFTInteger))
                    layer.CreateField(ogr.FieldDefn("Distance", ogr.OFTInteger))
                    layer.CreateField(ogr.FieldDefn("Latitude", ogr.OFTReal))
                    layer.CreateField(ogr.FieldDefn("Longitude", ogr.OFTReal))
                    layer.CreateField(ogr.FieldDefn("Elevation", ogr.OFTInteger))
                    layer.CreateField(ogr.FieldDefn("COB", ogr.OFTReal))
                    layer.CreateField(ogr.FieldDefn("BLOWUP", ogr.OFTReal))
                    layer.CreateField(ogr.FieldDefn("SETTLEMENT", ogr.OFTReal))
                    # layer.CreateField(ogr.FieldDefn("DATETIME", ogr.OFTDateTime))
                    # GIS end 
                    
                    
                    #als = db.Alignment.find({"$and":[{"alignment_set_id":a_set._id},{"PK":{"$gt":2128568}},{"PK":{"$lt":2129768}}]},{"PK":True,"COB":True,"BLOWUP":True, "PH":True, "DEM":True,"SETTLEMENT_MAX":True, "VOLUME_LOSS":True, "REFERENCE_STRATA":True, "SETTLEMENTS":True}).sort("PK", 1)
                    als = db.Alignment.find({"alignment_set_id":a_set._id},{"PK":True,"COB":True,"BLOWUP":True, "PH":True, "DEM":True,"SETTLEMENT_MAX":True, "VOLUME_LOSS":True, "REFERENCE_STRATA":True, "SETTLEMENTS":True}).sort("PK", 1)
                    a_list = list(als)
                    pks =[d['PK'] for d in a_list]
                    # scalo di fattore 100
                    cobs =[d['COB']/100 for d in a_list]
                    # scalo di fattore 100
                    blowups =[d['BLOWUP']/100 for d in a_list]
                    # amplifico di fattore 100
                    max_settlements =[d['SETTLEMENT_MAX']*100 for d in a_list]
                    phs =[d['PH']['coordinates'][2] for d in a_list]
                    dems =[d['DEM']['coordinates'][2] for d in a_list]
                    pkys =[d['PH']['coordinates'][1] for d in a_list]
                    pkxs =[d['PH']['coordinates'][0] for d in a_list]   
                    # punti medi
                    pmidx = []
                    pmidy = []
                    # punti a distanza 20 e 40
                    keys, dictValues = processSettlements(a_list)
                    pkxs_d_1 = defaultdict(list)
                    pkys_d_1 = defaultdict(list)
                    pkzs_d_1 = defaultdict(list)
                    pkxs_d_2 = defaultdict(list)
                    pkys_d_2 = defaultdict(list)
                    pkzs_d_2 = defaultdict(list)
                    mypoints = np.zeros((0,2))
                    myvalues = np.zeros(0,'f')
                    pcalc_x = []
                    pcalc_y = []
                    pcalc_z = []
                   
                    for i,x in enumerate(pkxs):

                        if i==0:
                            pass
                        else:
                            p1 = (pkxs[i-1],pkys[i-1])
                            p2 = (pkxs[i],pkys[i])
                            pm = mid_point(p1,p2)
                            pmidx.append(pm[0])
                            pmidy.append(pm[1])
                            for key in keys:
                                val = dictValues[key][i-1]
                                if key == 0.0:
                                    # pass
                                    mypoints = np.append(mypoints,[[pkxs[i-1],pkys[i-1]]],axis=0)
                                    myvalues = np.append(myvalues,[val],axis=0)
                                    pcalc_x.append(pkxs[i-1])
                                    pcalc_y.append(pkys[i-1])
                                    pcalc_z.append(val)
                                    # GIS 1.1
                                    feature = ogr.Feature(layer.GetLayerDefn())
                                    feature.SetField("Name", "PK %f %d" % (pks[i-1],0))
                                    feature.SetField("Type", "Central")
                                    feature.SetField("Alignment", str(sCode))
                                    feature.SetField("Distance",0)
                                    feature.SetField("PK", int(pks[i-1]))
                                    feature.SetField("Latitude", pkys[i-1])
                                    feature.SetField("Longitude", pkxs[i-1])
                                    feature.SetField("Elevation", phs[i-1])
                                    feature.SetField("COB", cobs[i-1])
                                    feature.SetField("SETTLEMENT", val)
                                    feature.SetField("BLOWUP", blowups[i-1])
                                    # feature.SetField("DATETIME", str(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])) 
                                    wkt = "POINT(%f %f)" %  (float(pkxs[i-1]) , float(pkys[i-1]))
                                    
                                    # Create the point from the Well Known Txt
                                    point = ogr.CreateGeometryFromWkt(wkt)

                                    # Set the feature geometry using the point
                                    feature.SetGeometry(point)
                                    # Create the feature in the layer (shapefile)
                                    layer.CreateFeature(feature)
                                    # Destroy the feature to free resources
                                    feature.Destroy()
                                    # GIS 1.1 end
                                else:    
                                    ret_d = pfromdistance_p1(p1,p2,key)
                                    x1 = ret_d[0][0]
                                    x2 = ret_d[1][0]
                                    y1 = ret_d[0][1]
                                    y2 = ret_d[1][1]
                                    pkxs_d_1[key].append(x1)
                                    pkxs_d_2[key].append(x2)
                                    pkys_d_1[key].append(y1)
                                    pkys_d_2[key].append(y2) 
                                    mypoints = np.append(mypoints,[[x1,y1]],axis=0)
                                    pcalc_x.append(x1)
                                    pcalc_y.append(y1)
                                    pcalc_z.append(val)
                                    myvalues = np.append(myvalues,[val],axis=0)
                                    mypoints = np.append(mypoints,[[x2,y2]],axis=0)
                                    pcalc_x.append(x2)
                                    pcalc_y.append(y2)
                                    pcalc_z.append(val)
                                    myvalues = np.append(myvalues,[val],axis=0)
                                    
                                    # GIS 1.1
                                    feature = ogr.Feature(layer.GetLayerDefn())
                                    feature.SetField("Name", "PK %f +%d" % (pks[i-1],int(key)))
                                    feature.SetField("Type", "Distance")
                                    feature.SetField("Alignment", str(sCode))
                                    feature.SetField("Distance",int(key))
                                    feature.SetField("PK", int(pks[i-1]))
                                    feature.SetField("Latitude", y1)
                                    feature.SetField("Longitude", x1)
                                    feature.SetField("Elevation", phs[i])
                                    feature.SetField("COB", cobs[i])
                                    feature.SetField("SETTLEMENT", val)
                                    feature.SetField("BLOWUP", blowups[i])
                                    #feature.SetField("DATETIME", str(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])) 
                                    wkt = "POINT(%f %f)" %  (float(x1) , float(y1))
                                    
                                    # Create the point from the Well Known Txt
                                    point = ogr.CreateGeometryFromWkt(wkt)

                                    # Set the feature geometry using the point
                                    feature.SetGeometry(point)
                                    # Create the feature in the layer (shapefile)
                                    layer.CreateFeature(feature)
                                    # Destroy the feature to free resources
                                    feature.Destroy()
                                    
                                    feature = ogr.Feature(layer.GetLayerDefn())
                                    feature.SetField("Name", "PK %f -%d" % (pks[i],int(key)))
                                    feature.SetField("Type", "Distance")           
                                    feature.SetField("Alignment", str(sCode))
                                    feature.SetField("Distance",int(key))
                                    feature.SetField("PK", int(pks[i]))
                                    feature.SetField("Latitude", y2)
                                    feature.SetField("Longitude", x2)
                                    feature.SetField("Elevation", dems[i])
                                    feature.SetField("COB", cobs[i])
                                    feature.SetField("SETTLEMENT", val)
                                    feature.SetField("BLOWUP", blowups[i])
                                    #feature.SetField("DATETIME", str(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])) 
                                    wkt = "POINT(%f %f)" %  (float(x2) , float(y2))
                                    
                                    # Create the point from the Well Known Txt
                                    point = ogr.CreateGeometryFromWkt(wkt)

                                    # Set the feature geometry using the point
                                    feature.SetGeometry(point)
                                    # Create the feature in the layer (shapefile)
                                    layer.CreateFeature(feature)
                                    # Destroy the feature to free resources
                                    feature.Destroy()
                                    
                                    # GIS 1.1 end
                    
                    x_min, x_max, y_min, y_max = layer.GetExtent()
                    
                    data_source.Destroy()
                    ############### END GIS
                    min_x = min(pcalc_x)
                    min_y = min(pcalc_y)
                    max_x = max(pcalc_x)
                    max_y = max(pcalc_y)
                    # Interpolazione ...forse non è la cosa giusta da fare
                    logger.info("x range %d" % (max_x - min_x) )
                    logger.info("y range %d" % (max_y - min_y) )
                    gx, gy =  np.mgrid[min_x:max_x,min_y:max_y]
                    m_interp_cubic = griddata(mypoints, myvalues, (gx, gy),method='nearest')
                    # plot
                    fig = plt.figure()
                    plt.title("Profilo %s" % sCode)
                    ### visualizza gli strati di riferimento
                    # fillBetweenStrata(a_list)
                    
                    ################################################
                    plt.plot(pks,phs, linewidth=2,label='Tracciato')
                    plt.plot(pks,dems,  linewidth=2,label='DEM' )
                    plt.plot(pks,cobs, label='COB / 100')
                    plt.plot(pks,blowups, label='BLOWUP / 100')
                    plt.plot(pks,max_settlements, label='SETTLEMENT_MAX * 100')
                    plt.axis([min(pks),max(pks),min(phs)-10,max(dems)+10])
                    plt.legend()
                    outputFigure(sPath, "profilo_%s.svg" % a_set.item["code"])            
                    logger.info("profilo_%s.png plotted in %s" % (a_set.item["code"], sPath))
                    plt.close(fig)
                    fig = plt.figure()
                    # stampa planimetria
                    plt.title("Planimetria") 

                    # filtro a zero tutto qeullo che sta sotto
                    # m_interp_cubic[ m_interp_cubic < 0.0] = 0.0
                        
                    clevels = np.arange(0., 0.04, 0.001)
                    cmap = LinearSegmentedColormap.from_list(name="Custom CMap", colors =["white", "blue", "red"], N=11)
                    contours = plt.contourf(gx, gy, m_interp_cubic,cmap = cm.jet, extend='both', levels=clevels)
                    cp = plt.contour(gx, gy, m_interp_cubic,linewidths=0.5,colors='k',levels=clevels)
                    
                    
                    # GIS create the data source
                    attr_name = "SETTLEMENT"
                    shpfname=os.path.join(sPath,"gis","contour_%s.shp" % sCode)
                    if os.path.exists(shpfname):
                        os.remove(shpfname)
                    dst_ds = driver.CreateDataSource(shpfname)
                    dst_layer = dst_ds.CreateLayer("contour_subsidence", srs, ogr.wkbPolygon)     
                    # Add the GIS fields we're interested in
                    dst_layer.CreateField(ogr.FieldDefn(attr_name, ogr.OFTReal))
                    field_align = ogr.FieldDefn("Alignment", ogr.OFTString)
                    field_align.SetWidth(24)
                    dst_layer.CreateField(field_align)
                    field_level = ogr.FieldDefn("LevelID", ogr.OFTString)
                    field_level.SetWidth(24)
                    dst_layer.CreateField(field_level)
                    # dst_layer.CreateField(ogr.FieldDefn("DATETIME", ogr.OFTDateTime))
                    # GIS end 
                    
                    for level in range(len(contours.collections)): 
                        paths = contours.collections[level].get_paths()  
                        for path in paths:  

                            feat_out = ogr.Feature( dst_layer.GetLayerDefn())  
                            feat_out.SetField( attr_name, contours.levels[level] )  
                            feat_out.SetField("Alignment", str(sCode))
                            feat_out.SetField("LevelID", str(level))
                            #feat_out.SetField("DATETIME", str(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])) 
                            pol = ogr.Geometry(ogr.wkbPolygon)  


                            ring = None              
                              
                            for i in range(len(path.vertices)):  
                                point = path.vertices[i]  
                                if path.codes[i] == 1:  
                                    if ring != None:  
                                        pol.AddGeometry(ring)  
                                    ring = ogr.Geometry(ogr.wkbLinearRing)  
                                      
                                ring.AddPoint_2D(point[0], point[1])  
                              

                            pol.AddGeometry(ring)  
                              
                            feat_out.SetGeometry(pol)  
                            if dst_layer.CreateFeature(feat_out) != 0:  
                                print "Failed to create feature in shapefile.\n"  
                                exit( 1 )  

                              
                            feat_out.Destroy()  


                    """
                    # Create the destination tiff data source
                    raster_fn=os.path.join(sPath,"smt_%s.tif" % sCode)
                    if os.path.exists(raster_fn):
                        os.remove(raster_fn)
                    
                    # Define pixel_size and NoData value of new raster

                    pixel_size = 1
                    NoData_value = -9999
                    x_res = int((max_x - min_x) / pixel_size)
                    y_res = int((max_y - min_y) / pixel_size)
                    target_ds = gdal.GetDriverByName('GTiff').Create(raster_fn, x_res, y_res, 1, gdal.GDT_Float32)
                    target_ds.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size))
                    band = target_ds.GetRasterBand(1)
                    band.WriteArray(m_interp_cubic)
                    outRasterSRS = osr.SpatialReference()
                    outRasterSRS.ImportFromEPSG(3949)
                    outRaster.SetProjection(outRasterSRS.ExportToWkt())
                    outband.FlushCache()
                    """
                    
                    
                    
                    plt.colorbar()
                    plt.plot(pkxs,pkys, "g-",label='Tracciato %s' % a_set.item["code"])
                    plt.plot(pkxs,pkys, "g.")

                    # Punti medi
                    plt.plot(pmidx,pmidy, "gx")
                    
                    for key in keys:
                        pkzs_d_1[key] = dictValues[key]
                        pkzs_d_2[key] = dictValues[key]
                        plt.plot(pkxs_d_1[key],pkys_d_1[key], "w.", ms=1)
                        plt.plot(pkxs_d_2[key],pkys_d_2[key], "w.", ms=1)
                    
                    array_x = np.asarray(pcalc_x)
                    array_y = np.asarray(pcalc_y)
                    array_z = np.asarray(pcalc_z)
                    plt.axis("equal")
                    outputFigure(sPath, "tracciato_%s.svg" % a_set.item["code"], format="svg")
                    logger.info("tracciato_%s.png plotted in %s" % (a_set.item["code"], sPath))
                    #plt.show()
                    plt.close(fig)
                    logger.info("plot_data terminated!")
    else:
        logger.error("Authentication failed")
Exemple #46
0
 def testChooseInitializer_Fraction(self):
   domain = Domain(type=Domain.FRACTION, low=-23, high=435)
   initializer = domain.chooseInitializer()
   self.assertTrue(initializer.is_rational)
   self.assertTrue(initializer >= Rational(domain.low, domain.high))
   self.assertTrue(initializer <= abs(Rational(domain.high, domain.low)))
from suds.client import Client
from domain import Domain
import sys

domain_name = sys.argv[1]
postmaster = sys.argv[2]

client = Client("http://localhost:8081/config-service/ConfigurationService?wsdl")

d = Domain(domain_name,postmaster)
d.add_to_config(client)
Exemple #48
0
 def testChooseInitializer_Real(self):
   domain = Domain(type=Domain.REAL, low=Real(20), high=Real(40))
   initializer = domain.chooseInitializer()
   self.assertTrue(initializer.is_real)
   self.assertTrue(initializer >= domain.low)
   self.assertTrue(initializer <= domain.high)
Exemple #49
0
 def testFraction(self):
   self.assertTrue(Domain.isValueInDomain(Domain.FRACTION, S.Zero))
   self.assertTrue(Domain.isValueInDomain(Domain.FRACTION, Rational(3,5)))
   self.assertFalse(Domain.isValueInDomain(Domain.FRACTION, S.Pi))
Exemple #50
0
 def testWholeNumber(self):
   self.assertTrue(Domain.isValueInDomain(Domain.WHOLE_NUMBER, S.Zero))
   self.assertFalse(Domain.isValueInDomain(Domain.WHOLE_NUMBER, -S.One))
Exemple #51
0
def plot_data(bAuthenticate, sPath):
    # connect to MongoDB
    client = MongoClient()
    db = client[database]
    # DB authentication if required
    if bAuthenticate:
        bLoggedIn = db.authenticate(username,password,source=source_database)
    else:
        bLoggedIn = True
    # cambio font size
    mpl.rcParams.update({'font.size': 6})
    if bLoggedIn:
        logger.info("Logged in")
        pd = db.Project.find_one({"project_code":"MFW001_0-010 Metro Paris-Ligne 15_T2A"})
        if pd:
            logger.info("Project %s found" % pd["project_name"])
            p = Project(db, pd)
            p.load()
            found_domains = Domain.find(db, {"project_id": p._id})
            for dom in found_domains:
                dm = Domain(db,dom)
                dm.load()
                # Example of query
                asets = db.AlignmentSet.find({"domain_id": dm._id})
                for aset in asets:
                    a_set = AlignmentSet(db,aset)
                    a_set.load()
                    sCode = a_set.item["code"]
                    als = db.Alignment.find({"alignment_set_id":a_set._id},{"PK":True,"P_TAMEZ":True,"COB":True,"P_EPB":True,"P_WT":True,"BLOWUP":True, "PH":True, "DEM":True,"SETTLEMENT_MAX":True, \
                    "TILT_MAX":True, "EPS_H_MAX":True, "VOLUME_LOSS":True, "K_PECK":True, "REFERENCE_STRATA":True, "SETTLEMENTS":True, "SENSIBILITY":True, "DAMAGE_CLASS":True, "VULNERABILITY":True,  \
                    "CONSOLIDATION_VALUE":True, "gamma_face":True, "gamma_tun":True, "sensibility_vbr_pk":True, "vibration_speed_mm_s_pk":True, "damage_class_vbr_pk":True, "vulnerability_vbr_pk":True}).sort("PK", 1)
                    a_list = list(als)
                    pks = []
                    pklabel = []
                    pkxticks = []
                    for d in a_list:
                        pk_value = round(d['PK']/10., 0) *10.
                        pks.append(pk_value)
                        hundreds = int(pk_value-int(pk_value/1000.)*1000)
                        if hundreds%100 == 0:
                            pkxticks.append(pk_value)
                            pklabel.append("%d+%03d" % (int(pk_value/1000.),hundreds ))
                    if sCode=='smi':
                        d_press = 0.5 # bar tra calotta e asse
                        d_press_wt = 0.35
                    else:
                        d_press = 0.7 # bar tra calotta e asse
                        d_press_wt = 0.5
                    
                    # scalo di fattore 100
#                    p_wts =[d['P_WT']/100 - d_press_wt for d in a_list]
                    p_wts = [(max(0., d['P_WT']/100. - d_press_wt)) for d in a_list]
                    # scalo di fattore 100
                    p_epms =[max(0., d['P_EPB']/100. - d_press) for d in a_list]
                    # scalo di fattore 100
                    p_tamezs=[max(0., d['P_TAMEZ']/100. - d_press) for d in a_list]
                    cobs =[max(0., d['COB']/100. - d_press) for d in a_list]
                    # scalo di fattore 100
                    blowups =[max(0., d['BLOWUP']/100. - d_press) for d in a_list]
                    # amplifico di fattore 100
                    volume_losss =[d['VOLUME_LOSS']*100. for d in a_list]
                    k_pecks =[d['K_PECK'] for d in a_list]
                    # amplifico di fattore 1000
                    max_settlements =[d['SETTLEMENT_MAX']*1000. for d in a_list]
                    tilts =[d['TILT_MAX']*1000. for d in a_list]
                    epshs =[d['EPS_H_MAX']*1000. for d in a_list]
                    consolidations =[d['CONSOLIDATION_VALUE'] for d in a_list]
                    sensibilities =[d['SENSIBILITY'] for d in a_list]
                    damages =[d['DAMAGE_CLASS'] for d in a_list]
                    vulnerabilities =[d['VULNERABILITY'] for d in a_list]
                    young_tuns =[d['gamma_tun'] for d in a_list]
                    young_faces =[d['gamma_face'] for d in a_list]
                    sensibility_vbr_pks =[d['sensibility_vbr_pk'] for d in a_list]
                    vibration_speed_mm_s_pks =[d['vibration_speed_mm_s_pk'] for d in a_list]
                    damage_class_vbr_pks =[d['damage_class_vbr_pk'] for d in a_list]
                    vulnerability_vbr_pks =[d['vulnerability_vbr_pk'] for d in a_list]
                    
                    
                    # "sensibility_vbr_pk":True, "vibration_speed_mm_s_pk":True, "damage_class_vbr_pk":True, "vulnerability_vbr_pk":True

#                    # plot
#                    fig = plt.figure()
#                    fig.set_size_inches(12, 3.54)
#                    plt.plot(pks,young_tuns, label='E_TUN - GPa')
#                    plt.plot(pks,young_faces, label='E_FACE - GPa')
#                    y_min = math.floor(min(min(young_tuns),min(young_faces))/1.)*1. 
#                    y_max = math.ceil(max(max(young_tuns),max(young_faces))/1.)*1. 
#                    my_aspect = 50./(abs(y_max-y_min)/9.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
#                    plt.axis([max(pks),min(pks),y_min,y_max])
#                    plt.xticks(pkxticks, pklabel, rotation='vertical')
#                    ax = plt.gca()
#                    ax.set_aspect(my_aspect)
#                    start, stop = ax.get_ylim()
#                    ticks = np.arange(start, stop + 1., 1.)
#                    ax.set_yticks(ticks)
#                    #ax.grid(True)
#                    plt.legend()
#                    #fig.set_dpi(1600)
#                    outputFigure(sPath, ("profilo_young_%s.svg" % sCode))
#                    logger.info("profilo_young.svg plotted in %s" % sPath)
#                    plt.show()

                    fig = plt.figure()
                    fig.set_size_inches(12, 3.54)
                    #plt.plot(pks,cobs, label='COB - bar')
                    plt.plot(pks,p_epms, label='P_EPB - bar')
                    plt.plot(pks,blowups, label='BLOWUP - bar')
                    plt.plot(pks,p_wts, label='P_WT - bar')
                    plt.plot(pks,p_tamezs, label='P_TAMEZ - bar')
                    y_min = math.floor(min(min(p_wts),min(cobs), min(p_epms), min(blowups))/.5)*.5-.5 
                    y_max = math.ceil(max(max(p_wts),max(cobs), max(p_epms), max(blowups))/.5)*.5+.5 
                    my_aspect = 50./(abs(y_max-y_min)/9.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    ax.set_aspect(my_aspect)
                    start, stop = ax.get_ylim()
                    ticks = np.arange(start, stop + .5, .5)
                    ax.set_yticks(ticks)
                    #ax.grid(True)
                    plt.legend()
                    #fig.set_dpi(1600)
                    outputFigure(sPath, ("profilo_pressioni_%s.svg" % sCode))
                    logger.info("profilo_pressioni.svg plotted in %s" % sPath)
                    plt.show()
#                    """
                    plt.plot(pks,volume_losss, label='VL percent')
                    plt.plot(pks,k_pecks, label='k peck')
                    y_min = math.floor(min(min(volume_losss), min(k_pecks))/.05)*.05-.05 
                    y_max = math.ceil(max(max(volume_losss), max(k_pecks))/.05)*.05+.05 
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/9.0) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    start, stop = ax.get_ylim()
                    ticks = np.arange(start, stop + .05, .05)
                    ax.set_yticks(ticks)
                    #ax.grid(True)
                    #plt.legend()
                    #fig.set_dpi(1600)
                    outputFigure(sPath, ("profilo_peck_%s.svg" % sCode))
                    logger.info("profilo_peck.svg plotted in %s" % sPath)
                    plt.show()

                    plt.plot(pks,max_settlements, label='SETTLEMENT_MAX (mm)')
                    y_min = 0. # math.floor(min(max_settlements))-1. 
                    y_max = 30. # math.ceil(max(max_settlements))+1. 
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/4.5) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    start, stop = ax.get_ylim()
                    ticks = np.arange(start, stop + 5., 5.)
                    ax.set_yticks(ticks)
                    #ax.grid(True)
                    #plt.legend()
                    #fig.set_dpi(1600)
                    outputFigure(sPath, ("profilo_cedimenti_%s.svg" % sCode))
                    logger.info("profilo_cedimenti.svg plotted in %s" % sPath)
                    plt.show()

                    plt.plot(pks,tilts, label='BETA (0/00)')
                    plt.plot(pks,epshs, label='EPS_H (0/00)')
                    y_min = 0. # math.floor(min(max_settlements))-1. 
                    y_max = 3.5 # math.ceil(max(max_settlements))+1. 
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/4.5) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    start, stop = ax.get_ylim()
                    ticks = np.arange(start, stop + .5, .5)
                    ax.set_yticks(ticks)
                    #ax.grid(True)
                    #plt.legend()
                    #fig.set_dpi(1600)
                    outputFigure(sPath, ("profilo_distorsioni_%s.svg" % sCode))
                    logger.info("profilo_distorsioni.svg plotted in %s" % sPath)
                    plt.show()

                    plt.plot(pks,sensibilities, label='SENSIBILITY (1-3)')
                    y_min = -0.5 
                    y_max = 3.5  
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/3.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    #start, stop = ax.get_ylim()
                    #ticks = np.arange(start, stop + 1., 1.)
                    ticks =[0., 1., 2., 3.]
                    ax.set_yticks(ticks)
                    #ax.grid(True)
                    #plt.legend()
                    #fig.set_dpi(1600)
                    outputFigure(sPath, ("profilo_sensibilita_%s.svg" % sCode))
                    logger.info("profilo_sensibilita.svg plotted in %s" % sPath)
                    plt.show()

                    plt.plot(pks,damages, label='DAMAGE CLASS (1-3)')
                    y_min = -0.5 
                    y_max = 3.5  
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/3.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    #start, stop = ax.get_ylim()
                    #ticks = np.arange(start, stop + 1., 1.)
                    ticks =[0., 1., 2., 3.]
                    ax.set_yticks(ticks)
                    #ax.grid(True)
                    #plt.legend()
                    #fig.set_dpi(1600)
                    outputFigure(sPath, ("profilo_danni_%s.svg" % sCode))
                    logger.info("profilo_danni.svg plotted in %s" % sPath)
                    plt.show()

                    plt.plot(pks,vulnerabilities, label='VULNERABILITY (1-3)')
                    y_min = -0.5 
                    y_max = 3.5  
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/3.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    #start, stop = ax.get_ylim()
                    #ticks = np.arange(start, stop + 1., 1.)
                    ticks =[0., 1., 2., 3.]
                    ax.set_yticks(ticks)
                    #ax.grid(True)
                    #plt.legend()
                    #fig.set_dpi(1600)
                    outputFigure(sPath, ("profilo_vulnerabilita_%s.svg" % sCode))
                    logger.info("profilo_vulnerabilita.svg plotted in %s" % sPath)
                    plt.show()

                    plt.plot(pks,consolidations, label='CONSOLIDATION (0-1)')
                    y_min = -0.3 
                    y_max = 1.3  
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/1.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    #start, stop = ax.get_ylim()
                    #ticks = np.arange(start, stop + 1., 1.)
                    ticks =[0., 1.]
                    ax.set_yticks(ticks)
                    #ax.grid(True)
                    #plt.legend()
                    #fig.set_dpi(1600)
                    outputFigure(sPath, ("profilo_consolidamenti_%s.svg" % sCode))
                    logger.info("profilo_consolidamenti.svg plotted in %s" % sPath)
                    plt.show()

                    plt.plot(pks,sensibility_vbr_pks, label='SENSIBILITY VBR (1-3)')
                    y_min = -0.5 
                    y_max = 3.5  
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/3.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    ticks =[0., 1., 2., 3.]
                    ax.set_yticks(ticks)
                    outputFigure(sPath, ("profilo_sensibilita_vbr_%s.svg" % sCode))
                    logger.info("profilo_sensibilita_vbr.svg plotted in %s" % sPath)
                    plt.show()
                    
                    plt.plot(pks,damage_class_vbr_pks, label='DAMAGE CLASS (1-3)')
                    y_min = -0.5 
                    y_max = 3.5  
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/3.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    ticks =[0., 1., 2., 3.]
                    ax.set_yticks(ticks)
                    outputFigure(sPath, ("profilo_danno_vbr_%s.svg" % sCode))
                    logger.info("profilo_danno_vbr.svg plotted in %s" % sPath)
                    plt.show()

                    plt.plot(pks,vulnerability_vbr_pks, label='VULNERABILITY (1-3)')
                    y_min = -0.5 
                    y_max = 3.5  
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/3.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    ticks =[0., 1., 2., 3.]
                    ax.set_yticks(ticks)
                    outputFigure(sPath, ("profilo_vulnerabilita_vbr_%s.svg" % sCode))
                    logger.info("profilo_vulnerabilita_vbr.svg plotted in %s" % sPath)
                    plt.show()

                    plt.plot(pks,vibration_speed_mm_s_pks, label='VIBRATION SPEED (mm/s)')
                    y_min = -0.5 
                    y_max = 12.5  
                    plt.axis([max(pks),min(pks),y_min,y_max])
                    plt.xticks(pkxticks, pklabel, rotation='vertical')
                    ax = plt.gca()
                    my_aspect = 50./(abs(y_max-y_min)/3.) # 50 m di profilo sono 1 cm in tavola, in altezza ho 9 cm a disposizione
                    ax.set_aspect(my_aspect)
                    ticks =[0., 2., 3., 5.,  6.,  9., 12.]
                    ax.set_yticks(ticks)
                    outputFigure(sPath, ("profilo_velocita_vbr_%s.svg" % sCode))
                    logger.info("profilo_velocita_vbr.svg plotted in %s" % sPath)
                    plt.show()

                    """
                    
                    sensibility_vbr_pks =[d['sensibility_vbr_pk'] for d in a_list]
                    vibration_speed_mm_s_pks =[d['vibration_speed_mm_s_pk'] for d in a_list]
                    damage_class_vbr_pks =[d['damage_class_vbr_pk'] for d in a_list]
                    vulnerability_vbr_pks =[d['vulnerability_vbr_pk'] for d in a_list]

                    """
                    
                    
#                    """

                    logger.info("plot_data terminated!")
    else:
        logger.error("Authentication failed")
Exemple #52
0
formatter = logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
# reading config file
sCFGName = 'smt.cfg'
smtConfig = ConfigParser.RawConfigParser()
smtConfig.read(sCFGName)
# setup DB parameter
host = smtConfig.get('MONGODB','host')
database = smtConfig.get('MONGODB','database')
source_database = smtConfig.get('MONGODB','source_database')
username = smtConfig.get('MONGODB','username')
password = smtConfig.get('MONGODB','password')
# connect to MongoDB
client = MongoClient()
db = client[database]
# DB authentication
db.authenticate(username,password,source=source_database)
# Search for project_code = "MFW001_0-010 Metro Paris-Ligne 15_T2A"
pd = db.Project.find_one({"project_code":"MFW001_0-010 Metro Paris-Ligne 15_T2A"})
p = Project(db, pd)
p.load()
found_domains = Domain.find(db, {"project_id": p._id})
for dom in found_domains:
    d = Domain(db,dom)
    d.load()
 
    # Example of aggregation
    aggrList = Alignment.aggregate_by_strata(db, d._id)
    for ii in aggrList:
        print ii
Exemple #53
0
# make image with map of the file location
n.write_map(oFileName + '_map.png')

# Reprojected image into stereographic projection
# 1. Cancel previous reprojection
# 2. Get corners of the image
# 3. Create Domain with stereographic projection, corner coordinates and resolution 1000m
# 4. Reproject
# 5. Write image
n.reproject() # 1.
lons, lats = n.get_corners() # 2.
meanLon = sum(lons, 0.0) / 4.
meanLat = sum(lats, 0.0) / 4.
srsString = "+proj=stere +lon_0=%f +lat_0=%f +k=1 +ellps=WGS84 +datum=WGS84 +no_defs" % (meanLon, meanLat)
extentString = '-lle %f %f %f %f -tr 75 75' % (min(lons), min(lats), max(lons), max(lats))
dStereo = Domain(srs=srsString, ext=extentString) # 3.
dStereo.write_map(oFileName + '_stereo_map.png')
print dStereo
n.reproject(dStereo) # 4.

n.write_figure(oFileName + '_pro_stereo.png', bands=[3], clim=[-20,0]) # 5.


# Make image reprojected onto map of Northern Europe
# 1. Create Domain object. It describes the desired grid of reprojected image:
# projection, resolution, size, etc. In this case it is geographic projection;
# -10 - 30 E, 50 - 70 W; 2000 x 2000 pixels
# 2. Reproject the Nansat object
# 3. Make simple image
srsString = "+proj=latlong +ellps=WGS84 +no_defs"
extentString = '-lle %f %f %f %f -ts 1000 1000' % (min(lons), min(lats), max(lons), max(lats))
Exemple #54
0
    def create_domain(self, name, ip_address):

        return Domain.create_new(name, ip_address, self.authentication_token)
Exemple #55
0
 def testInteger(self):
   self.assertTrue(Domain.isValueInDomain(Domain.INTEGER, S.Zero))
   self.assertFalse(Domain.isValueInDomain(Domain.INTEGER, Rational(3,5)))
Exemple #56
0
 def testReal(self):
   self.assertTrue(Domain.isValueInDomain(Domain.REAL, S.Zero))
   self.assertTrue(Domain.isValueInDomain(Domain.REAL, Rational(3,5)))
   self.assertTrue(Domain.isValueInDomain(Domain.REAL, S.Pi))
   self.assertFalse(Domain.isValueInDomain(Domain.REAL, S.ImaginaryUnit))    
Exemple #57
0
 def iterate_states(self, depth, return_depth=False):
     domain = Domain(None, False)
     domain.create_iterator = lambda: StatesIterator(self, depth, return_depth)
     return domain
Exemple #58
0
 def get_domain(self):
     from domain import Domain
     d = Domain(self)
     if d.exists():
         return d
     return None