Esempio n. 1
0
 def get(self):
     app.logger.info('apiDomainList')
     l = db.get('cache-domain-list')
     if l is None:
         domainList = Domains(cfg.dataPath, cfg.domainPath, cfg.domains)
         l = domainList.keys()
         db.set('cache-domain-list', json.dumps(l))
     else:
         l = json.loads(l)
     return l
Esempio n. 2
0
def load_domains(path):
    '''Load domains from a domains.yaml.

    If domains.yaml is not found, then a single 'app' domain referring to the
    top-level build folder is created and returned.
    '''
    domains_file = Path(path) / 'domains.yaml'

    if not domains_file.is_file():
        return Domains.from_data({'default': 'app',
                                  'build_dir': path,
                                  'domains': [{'name': 'app', 'build_dir': path}]})

    return Domains.from_file(domains_file)
Esempio n. 3
0
    def __init__(self, kRef, meshname, doms, J_is='BlockedDiscrete'):

        if isinstance(doms, list):
            domains = Domains(doms)
        elif isinstance(doms, Domains):
            domains = doms
        else:
            raise TypeError(
                'configuration needs to be a list or a Domains class')

        self._collected = False

        self._assembled = False
        self._A_assembled = False
        self._X_assembled = False
        self._J_assembled = False
        self._iJ_assembled = False

        self._J_is = J_is

        self.domains = domains
        self.N = len(domains)

        print('==Importing Grid/Mesh', end=' ', flush=True)
        self.grid = grid = bem.import_grid(meshname)
        print('done.', flush=True)

        N = self.N
        self.opA = bem.BlockedOperator(N, N)
        self.opX = bem.BlockedOperator(N, N)
        self.opI = bem.BlockedOperator(N, N)

        if np.abs(kRef) <= 0.0:
            kernel = 'lapl'
            self.kRef = 0.0
            dtype = np.float
        else:
            kernel = 'helm'
            self.kRef = kRef  #float(kRef)
            dtype = np.complex
        self.kernel = kernel

        if dtype is None:
            if kernel == 'helm':
                dtype = np.complex
            else:
                dtype = np.float
        self.dtype = dtype

        if kernel == 'helm':
            funEFIE = lambda trial, ran, test, k: bem.operators.boundary.maxwell.electric_field(
                trial, ran, test, k)
            funMFIE = lambda trial, ran, test, k: bem.operators.boundary.maxwell.magnetic_field(
                trial, ran, test, k)

        self._funEFIE = funEFIE
        self._funMFIE = funMFIE

        self._funI = bem.operators.boundary.sparse.maxwell_identity
Esempio n. 4
0
    conf = sanitize_config(init_offset=truefalse,
                           tag=i+1,
                           kRef=kRef,
                           rad=rads[i],
                           phys=phys[i],
                           center=centers[i],
    )
    dgen = generate_concentric_dict(conf)
    cmds = write_params_geo(conf)
    call(cmds)

    dgens.append(dgen)

doms = merge_msh_bubbles(dgens)

myd = Domains(doms)
myd.write2dot('graph.dot')
call(['dot', '-Teps', 'graph.dot'], stdout=open('graph.eps', 'wb'))

dd = myd

print(N)

##################################

meshname = "./geo/all.msh"


mtf = MultiTrace(kRef, meshname, dd)

At, X, J, iJ = mtf.tolinop()
Esempio n. 5
0
        if "start.bg" in href and "javascript:" not in href:
            inbound.add(href)
        elif "link.php" in href:
            outbound.add(href)
        else:
            others.add(href)

    return {
        "inbound": inbound,
        "outbound": outbound,
        "others": others
    }


while True:
    domains_to_visit = Domains.get_all_unvisited_domains(conn)  
    
    if len(domains_to_visit) == 0:
        break

    for domain_row in domains_to_visit:
        result = collect_domain(domain_row["domain"])
    
    domain_id = domain_row["domain_id"]
    
    Domains.visit_domain(conn, domain_id)
    Domains.insert_domains(conn, result["inbound"])
    Links.insert_links(conn, result["outbound"], domain_id)
    
    print("Sleeping for 20 seconds ZzZzz")
    time.sleep(20)
Esempio n. 6
0
    def __init__(self,
                 kRef,
                 meshname,
                 doms,
                 J_is='BlockedDiscrete',
                 X_is='BlockedDiscrete',
                 use_slp=True):

        if isinstance(doms, list):
            domains = Domains(doms)
        elif isinstance(doms, Domains):
            domains = doms
        else:
            raise TypeError(
                'configuration needs to be a list or a Domains class')

        self._collected = False

        self._assembled = False
        self._A_assembled = False
        self._X_assembled = False
        self._J_assembled = False
        self._iJ_assembled = False

        if not J_is in ['BlockedDiscrete', 'CSC', 'Blocked']:
            warnings.warn('{0} is not supported. Default used {1}'.format(
                J_is, 'BlockedDiscrete'))
            J_is = 'BlockedDiscrete'
        self._J_is = J_is

        if not X_is in ['BlockedDiscrete', 'Blocked']:
            warnings.warn('{0} is not supported. Default used {1}'.format(
                J_is, 'BlockedDiscrete'))
            X_is = 'BlockedDiscrete'
        self._X_is = X_is

        self.use_slp = use_slp

        print('==J_is: {0} , X_is: {1} , use_slp={2}'.format(
            J_is, X_is, use_slp))

        self.domains = domains
        self.N = len(domains)

        print('==Importing Grid/Mesh {}'.format(meshname), end=' ', flush=True)
        self.grid = grid = bem.import_grid(meshname)
        print('done.', flush=True)

        N = self.N
        self.opA = bem.BlockedOperator(N, N)
        self.opX = bem.BlockedOperator(N, N)
        self.opI = bem.BlockedOperator(N, N)

        if np.abs(kRef) == 0.0:
            kernel = 'lapl'
            self.kRef = 0.0
            dtype = np.float
        else:
            kernel = 'helm'
            self.kRef = kRef  #float(kRef)
            dtype = np.complex
        self.kernel = kernel

        if not dtype is None:
            if kernel == 'helm':
                if dtype != np.complex:
                    warnings.warn('Helmholtz is complex. dtype={}'.format(
                        np.complex))
                    dtype = np.complex
            else:
                if dtype != np.float:
                    warnings.warn('Unsupported dtype. Converted to {}'.format(
                        np.float))
                    dtype = np.float
        self.dtype = dtype

        if kernel == 'helm':
            funK = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.double_layer(
                trial, ran, test, k)
            funV = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.single_layer(
                trial, ran, test, k)
            funQ = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.adjoint_double_layer(
                trial, ran, test, k)
            funW = lambda trial, ran, test, k: bem.operators.boundary.helmholtz.hypersingular(
                trial, ran, test, k, use_slp=use_slp)
        else:
            funK = lambda trial, ran, test, k: bem.operators.boundary.laplace.double_layer(
                trial, ran, test)
            funV = lambda trial, ran, test, k: bem.operators.boundary.laplace.single_layer(
                trial, ran, test)
            funQ = lambda trial, ran, test, k: bem.operators.boundary.laplace.adjoint_double_layer(
                trial, ran, test)
            funW = lambda trial, ran, test, k: bem.operators.boundary.laplace.hypersingular(
                trial, ran, test, use_slp=use_slp)

        self._funK, self._funV = funK, funV
        self._funW, self._funQ = funW, funQ

        self._funI = bem.operators.boundary.sparse.identity

        self.spaces = [(('test_d', 'trial_d'), ('test_n', 'trial_n'))
                       for d in domains]
Esempio n. 7
0
    return cfg


if __name__ == '__main__':
    import argparse

    parser = argparse.ArgumentParser()
    parser.add_argument('--config',  default='./indie-stats.cfg')
    parser.add_argument('--echo',    default=True,  action='store_true')
    parser.add_argument('--seed'  ,  default=False, action='store_true')
    parser.add_argument('--refresh', default=False, action='store_true')

    args = parser.parse_args()
    cfg  = loadConfig(args.config)

    initLogging(log, cfg['dataPath'], args.echo)

    log.info('starting')

    domains = Domains(cfg['dataPath'], cfg['domainPath'], cfg['domains'])
    log.info('%d domains loaded from datastore' % len(domains))

    if args.seed:
        gather(cfg, domains)

    if args.refresh:
        refresh(cfg, domains)

    domains.store()
Esempio n. 8
0
    for link in soup.find_all("a"):
        href = link.get("href")

        if href is None:
            continue

        if "start.bg" in href and "javascript:" not in href:
            inbound.add(href)
        elif "link.php" in href:
            outbound.add(href)
        else:
            others.add(href)

    return {"inbound": inbound, "outbound": outbound, "others": others}


while True:
    domains_to_visit = Domains.get_all_unvisited_domains(conn)

    if len(domains_to_visit) == 0:
        break

    for domain_row in domains_to_visit:
        result = collect_domain(domain_row["domain"])

    domain_id = domain_row["domain_id"]

    Domains.visit_domain(conn, domain_id)
    Domains.insert_domains(conn, result["inbound"])
    Links.insert_links(conn, result["outbound"], domain_id)