示例#1
0
文件: app.py 项目: essil1/ase-laser
def row(project, uid):
    db = databases[project]
    if not hasattr(db, 'meta'):
        db.meta = ase.db.web.process_metadata(db)
    prefix = '{}/{}-{}-'.format(tmpdir, project, uid)
    key = db.meta.get('unique_key', 'id')
    try:
        uid = int(uid)
    except ValueError:
        pass
    row = db.get(**{key: uid})
    s = Summary(row, db.meta, SUBSCRIPT, prefix)
    atoms = Atoms(cell=row.cell, pbc=row.pbc)
    n1, n2, n3 = kptdensity2monkhorstpack(atoms, kptdensity=1.8, even=False)
    return render_template('summary.html',
                           project=project,
                           s=s,
                           uid=uid,
                           n1=n1,
                           n2=n2,
                           n3=n3,
                           home=home,
                           back=True,
                           ase_db_footer=ase_db_footer,
                           md=db.meta,
                           open_ase_gui=open_ase_gui)
def get_bulk(name, proto, id=None, method="gpaw"):
    # Get bulk properties
    if id is None:
        res = list(db.select(formula=name, prototype=proto))
        if len(res) == 0:
            return None
        r = res[0]
    else:
        r = db.get(id)
    try:
        if method.lower() == "gpaw":
            L = r.bulk_L
            eps_para = (r.bulk_eps_x + r.bulk_eps_y) / 2
            eps_perp = r.bulk_eps_z
            e = r.gap_hse
        # VASP version below:
        elif method.lower() == "vasp":
            L = r.bulk_L_vasp
            eps_para = (r.bulk_eps_x_vasp + r.bulk_eps_y_vasp) / 2
            eps_perp = r.bulk_eps_z_vasp
            if r.bulk_gap < 0:
                e = r.gap_hse
            else:
                e = r.bulk_gap
        else:
            return None
        if eps_para < 0 or eps_perp < 0:
            return None
    except Exception:
        return None
    return L, eps_para, eps_perp, e
示例#3
0
def open_row(id):
    con_id = int(request.args["x"])
    opened = connections[con_id].opened
    if id in opened:
        opened.remove(id)
        return ""
    opened.add(id)
    return render_template("more.html", dct=db.get(id), id=id, cid=con_id)
示例#4
0
def open_row(id):
    con_id = int(request.args['x'])
    opened = connections[con_id].opened
    if id in opened:
        opened.remove(id)
        return ''
    opened.add(id)
    return render_template('more.html', dct=db.get(id), id=id, cid=con_id)
示例#5
0
def db_read_row(dbname, id):
    #-#
    import ase.db
    db = ase.db.connect(dbname)
    # Read all information for one row in the database
    row = db.get(id=id)

    # Create Atoms object and glu the data from the row for convenience
    structure = row.toatoms()
    structure.row = row
    return structure
示例#6
0
def main(argv):
    relax_atoms = (argv[1] == "atoms")
    runID = int(argv[0])
    print("Running job: %d" % (runID))
    db_name = db_name_atoms
    #db_name = "/home/ntnu/davidkl/Documents/GPAWTutorials/ceTest.db"
    db = ase.db.connect(db_name)

    new_run = not db.get(id=runID).key_value_pairs["started"]
    # Update the databse
    db.update(runID, started=True, converged=False)

    atoms = db.get_atoms(id=runID)

    calc = EAM(potential="/home/davidkl/Documents/EAM/mg-al-set.eam.alloy")
    atoms.set_calculator(calc)
    init_energy = atoms.get_potential_energy()

    logfile = "CE_eam/ceEAM%d.log" % (runID)
    traj = "CE_eam/ceEAM%d.traj" % (runID)
    trajObj = Trajectory(traj, 'w', atoms)

    if (relax_atoms):
        relaxer = BFGS(atoms, logfile=logfile)
        relaxer.attach(trajObj)
        relaxer.run(fmax=0.025)
        energy = atoms.get_potential_energy()
    else:
        res = minimize(target_function, x0=4.05, args=(atoms, ))
        a = res["x"]
        atoms = set_cell_parameter(atoms, a)
        energy = atoms.get_potential_energy()
        print("Final energy: {}, final a_la: {}".format(energy, a))
    row = db.get(id=runID)
    del db[runID]
    kvp = row.key_value_pairs
    kvp["init_energy"] = init_energy
    runID = db.write(atoms, key_value_pairs=kvp)
    db.update(runID, converged=True)
    print("Energy: %.2E eV/atom" % (energy / len(atoms)))
    print("Initial energy: %.2E eV/atom" % (init_energy / len(atoms)))
示例#7
0
def main(runID):
    db = ase.db.connect(db_name())
    atoms = db.get_atoms(id=runID)
    row = db.get(id=runID)
    n_kpt = row.n_kpt
    cutoff = row.cutoff

    calc = gp.GPAW(mode=gp.PW(cutoff),
                   xc="PBE",
                   kpts=(n_kpt, n_kpt, n_kpt),
                   nbands="120%")
    atoms.set_calculator(calc)
    energy = atoms.get_potential_energy()
    db.update(runID, trial_energy=energy)
示例#8
0
def test_db(name):
    print(name)
    db = ase.db.connect(name, append=False)
    db.write(Atoms(), x=1, data={'a': 1})
    db.update(1, y=2, data={'b': 2})
    db.update(1, delete_keys=['x'])
    row = db.get(1)
    print(row.y, row.data)
    assert 'x' not in row
    db.update(1, atoms=Atoms('H'))
    row = db.get(1)
    print(row.y, row.data, row.numbers)
    assert (row.numbers == [1]).all()
    assert sorted(row.data) == ['a', 'b']

    db.write(Atoms(), id=1)
    row = db.get(1)
    assert len(row.data) == 0
    assert len(row.key_value_pairs) == 0
    assert len(row.numbers) == 0

    # N = 100
    N = 5
    for i in range(N):
        db.write(Atoms('H10'), i=i, data={'c': 3})

    t0 = time()
    for id in range(2, 2 + N):
        db.update(id, z=3)
    print(time() - t0)

    # This should be faster for large N:
    t0 = time()
    with db:
        for id in range(2, 2 + N):
            db.update(id, z=3)
    print(time() - t0)
示例#9
0
def db_read_row(dbname, id):
    """Reads a specific row in a ASE database.

    Keyword arguments:
    dbname -- database name.
    id -- id number of the row to read.

    """
    import ase.db

    db = ase.db.connect(dbname)

    # Read all information for one row in the database
    row = db.get(id=id)

    structure = row.toatoms()
    structure.row = row
    return structure
示例#10
0
def summary(id):
    db = database()
    if db is None:
        return ''
    if not hasattr(db, 'meta'):
        db.meta = ase.db.web.process_metadata(db)
    prfx = prefix() + str(id) + '-'
    row = db.get(id)
    s = Summary(row, db.meta, SUBSCRIPT, prfx, tmpdir)
    atoms = Atoms(cell=row.cell, pbc=row.pbc)
    n1, n2, n3 = kptdensity2monkhorstpack(atoms, kptdensity=1.8, even=False)
    return render_template('summary.html',
                           project=request.args.get('project', 'default'),
                           projects=projects,
                           s=s,
                           n1=n1,
                           n2=n2,
                           n3=n3,
                           home=home,
                           md=db.meta,
                           open_ase_gui=open_ase_gui)
示例#11
0
def summary(id):
    db = database()
    if not hasattr(db, 'meta'):
        db.meta = ase.db.web.process_metadata(db)
    prfx = prefix() + str(id) + '-'
    row = db.get(id)
    s = Summary(row, db.meta, SUBSCRIPT, prfx, tmpdir)
    atoms = Atoms(cell=row.cell, pbc=row.pbc)
    n1, n2, n3 = kptdensity2monkhorstpack(atoms,
                                          kptdensity=1.8,
                                          even=False)
    return render_template('summary.html',
                           project=request.args.get('project', 'default'),
                           projects=projects,
                           s=s,
                           n1=n1,
                           n2=n2,
                           n3=n3,
                           home=home,
                           md=db.meta,
                           open_ase_gui=open_ase_gui)
示例#12
0
def choose_adsorbate(adsorbate_database):
    '''
    Chooses a bulks from our database at random as long as the bulk contains
    all the specified elements.

    Args:
        adsorbate_database   A string pointing to the ASE *.db object that contains
                             the adsorbates you want to consider.
    Returns:
        atoms           `ase.Atoms` object of the adsorbate
        simles          SMILES-formatted representation of the adsorbate
        bond_indices    list of integers indicating the indices of the atoms in
                        the adsorbate that are meant to be bonded to the surface
    '''
    db = ase.db.connect(adsorbate_database)
    ads_idx = random.choice(list(range(db.count())))
    row = db.get(ads_idx + 1)  # ase.db's don't 0-index

    atoms = row.toatoms()
    data = row.data
    smiles = data['SMILE']
    bond_indices = data['bond_idx']
    return atoms, smiles, bond_indices
            # thick.append(get_thick(mol))

alpha_x = numpy.array(alpha_x)
alpha_z = numpy.array(alpha_z)
eps_x_3D = numpy.array(eps_x_3D)
eps_z_3D = numpy.array(eps_z_3D)
Eg_HSE = numpy.array(Eg_HSE)
# thick = numpy.array(thick)

eps_x_gpaw = []
eps_z_gpaw = []
alpha_z_gpaw = []
Eg_gpaw = []
L_gpaw = []
for db_id in range(1, db.count() + 1):  # db index starts with 1
    mol = db.get(db_id)
    # if any(hasattr(mol, key) is False for key in ["alphax", "alphay", "alphaz",
    # "bulk_L", "bulk_eps_x", "bulk_eps_y",
    # "bulk_eps_z"]):
    # continue
    # if mol.bulk_calculated is False:
    # continue
    try:
        ax = (mol.alphax + mol.alphay) / 2
        az = mol.alphaz
        L, ex, ez, e = get_bulk(None, None, db_id, method="gpaw")
        ex_simu = 1 + 4 * pi * ax / L
        ez_simu = 1 / (1 - 4 * pi * az / L)
        # ez_simu = 4 * pi * az / L
        eps_x_gpaw.append((ex, ex_simu))
        eps_z_gpaw.append((ez, ez_simu))
示例#14
0
def main(argv):
    relaxCell = True
    system = "AlMg"
    runID = int(argv[0])
    print("Running job: %d" % (runID))
    db_paths = [
        "/home/ntnu/davidkl/GPAWTutorial/CE/ce_hydrostatic.db",
        "ce_hydrostatic.db", "/home/davidkl/GPAWTutorial/CE/ce_hydrostatic.db"
    ]
    for path in db_paths:
        if (os.path.isfile(path)):
            db_name = path
            break
    #db_name = "/home/ntnu/davidkl/Documents/GPAWTutorials/ceTest.db"
    db = ase.db.connect(db_name)

    con = sq.connect(db_name)
    cur = con.cursor()
    cur.execute("SELECT value FROM text_key_values WHERE id=? AND key='name'",
                (runID, ))
    name = cur.fetchone()[0]
    con.close()

    new_run = not db.get(id=runID).key_value_pairs["started"]
    # Update the databse
    db.update(runID, started=True, converged=False)

    atoms = db.get_atoms(id=runID)
    if (system == "AlMg" and new_run == False):
        atoms = change_cell_composition_AlMg(atoms)

    convergence = {"density": 1E-4, "eigenstates": 4E-8}
    calc = gp.GPAW(mode=gp.PW(500),
                   xc="PBE",
                   kpts=(4, 4, 4),
                   nbands="120%",
                   convergence=convergence)
    atoms.set_calculator(calc)

    logfile = "ceTest%d.log" % (runID)
    traj = "ceTest%d.traj" % (runID)
    trajObj = Trajectory(traj, 'w', atoms)

    storeBest = SaveToDB(db_name, runID, name)

    try:
        precon = Exp(mu=1.0, mu_c=1.0)
        if (relaxCell):
            uf = UnitCellFilter(atoms, hydrostatic_strain=True)
            relaxer = PreconLBFGS(uf,
                                  logfile=logfile,
                                  use_armijo=True,
                                  precon=precon)
        else:
            relaxer = PreconFIRE(atoms, logfile=logfile, precon=precon)
            relaxer = SciPyFminCG(atoms, logfile=logfile)
        relaxer.attach(trajObj)
        relaxer.attach(storeBest, interval=1, atoms=atoms)
        if (relaxCell):
            relaxer.run(fmax=0.025, smax=0.003)
        else:
            relaxer.run(fmax=0.025)
        energy = atoms.get_potential_energy()
        db.update(storeBest.runID, converged=True)
        print("Energy: %.2E eV/atom" % (energy / len(atoms)))
        print("Preconditioner parameters")
        print("Mu:", precon.mu)
        print("Mu_c:", precon.mu_c)
    except Exception as exc:
        print(exc)
示例#15
0
def main(argv):
    relax_mode = "cell"  # both, cell, positions
    system = "AlMg"
    runID = int(argv[0])
    print("Running job: %d" % (runID))
    db_paths = [
        "/home/ntnu/davidkl/GPAWTutorial/CE/almg_217.db", "almg_217.db",
        "/home/davidkl/GPAWTutorial/CE/almg_217.db"
    ]
    for path in db_paths:
        if (os.path.isfile(path)):
            db_name = path
            break
    #db_name = "test_db.db"
    db = ase.db.connect(db_name)

    con = sq.connect(db_name)
    cur = con.cursor()
    cur.execute("SELECT value FROM text_key_values WHERE id=? AND key='name'",
                (runID, ))
    name = cur.fetchone()[0]
    con.close()

    new_run = not db.get(id=runID).key_value_pairs["started"]
    # Update the databse
    db.update(runID, started=True, converged=False)

    atoms = db.get_atoms(id=runID)

    calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=(4, 4, 4), nbands="120%")
    #calc = gp.GPAW( mode=gp.PW(500), xc="PBE", kpts=(4,4,4), nbands=-10 )
    atoms.set_calculator(calc)

    logfile = "almg_bcc%d.log" % (runID)
    traj = "almg_bcc%d.traj" % (runID)
    trajObj = Trajectory(traj, 'w', atoms)

    storeBest = SaveToDB(db_name, runID, name, mode=relax_mode)
    volume = atoms.get_volume()

    try:
        precon = Exp(mu=1.0, mu_c=1.0)
        fmax = 0.025
        smax = 0.003
        if (relax_mode == "both"):
            relaxer = PreconLBFGS(atoms,
                                  logfile=logfile,
                                  use_armijo=True,
                                  precon=precon,
                                  variable_cell=True)
        elif (relax_mode == "positions"):
            relaxer = SciPyFminCG(atoms, logfile=logfile)
            #relaxer = BFGS( atoms, logfile=logfile )
        elif (relax_mode == "cell"):
            str_f = StrainFilter(atoms, mask=[1, 1, 1, 0, 0, 0])
            relaxer = BFGS(str_f, logfile=logfile)
            fmax = smax * volume

        relaxer.attach(trajObj)
        relaxer.attach(storeBest, interval=1, atoms=atoms)
        if (relax_mode == "both"):
            relaxer.run(fmax=fmax, smax=smax)
        else:
            relaxer.run(fmax=fmax)
        energy = atoms.get_potential_energy()

        if (relax_mode == "positions"):
            db.update(storeBest.runID, converged_force=True)
        elif (relax_mode == "cell"):
            db.update(storeBest.runID, converged_stress=True)
        else:
            db.update(storeBest.runID,
                      converged_stress=True,
                      converged_force=True)

        row = db.get(id=storeBest.runID)
        conv_force = row.get("converged_force", default=0)
        conv_stress = row.get("converged_stress", default=0)
        if ((conv_force == 1) and (conv_stress == 1)):
            db.update(storeBest.runID, converged=True)
    except Exception as exc:
        print(exc)
示例#16
0
def main(argv):
    relax_mode = "both"  # both, cell, positions
    system = "AlMg"
    runID = int(argv[0])
    nkpt = int(argv[1])

    single_point = False
    if (len(argv) >= 3):
        single_point = (int(argv[2]) == 1)
    print("Running job: %d" % (runID))
    db_paths = [
        "/home/ntnu/davidkl/GPAWTutorial/CE/almg_fcc_vac.db",
        "almg_fcc_vac.db", "/home/davidkl/GPAWTutorial/CE/almg_fcc_vac.db"
    ]
    for path in db_paths:
        if (os.path.isfile(path)):
            db_name = path
            break
    #db_name = "almgsi_test_db.db"
    db = ase.db.connect(db_name)
    name = db.get(id=runID).key_value_pairs["name"]
    new_run = not db.get(id=runID).key_value_pairs["started"]

    # Update the databse
    db.update(runID, started=True, converged=False)
    db.update(runID, nkpt=nkpt)

    atoms = db.get_atoms(id=runID)
    atoms = delete_vacancies(atoms)

    if (len(atoms) == 1):
        nbands = -10
    else:
        nbands = "120%"
    kpts = (nkpt, nkpt, nkpt)
    try:
        restart_name = SaveRestartFiles.restart_name(name)
        atoms, calc = gp.restart(restart_name)
    except:
        calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=kpts, nbands=nbands)
        atoms.set_calculator(calc)

    if (single_point):
        calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=kpts, nbands=nbands)
        atoms.set_calculator(calc)

    logfile = "almg_fcc_vac{}.log".format(name)
    traj = "almg_bcc{}.traj".format(name)
    db.update(runID, trajfile=traj)
    trajObj = Trajectory(traj, 'w', atoms)

    #storeBest = SaveToDB(db_name,runID,name,mode=relax_mode)
    save_calc = SaveRestartFiles(calc, name)
    update_db_info = UpdateDBInfo(db_name, runID, atoms)
    volume = atoms.get_volume()

    try:
        precon = Exp(mu=1.0, mu_c=1.0)
        fmax = 0.025
        smax = 0.003
        if (relax_mode == "both"):
            relaxer = PreconLBFGS(atoms,
                                  logfile=logfile,
                                  use_armijo=True,
                                  variable_cell=True)
        elif (relax_mode == "positions"):
            #relaxer = SciPyFminCG( atoms, logfile=logfile )
            relaxer = BFGS(atoms, logfile=logfile)
        elif (relax_mode == "cell"):
            str_f = StrainFilter(atoms, mask=[1, 1, 1, 0, 0, 0])
            relaxer = BFGS(str_f, logfile=logfile)
            fmax = smax * volume

        relaxer.attach(trajObj)
        #relaxer.attach( storeBest, interval=1, atoms=atoms )
        relaxer.attach(save_calc, interval=1)
        relaxer.attach(update_db_info, interval=1)
        if (not single_point):
            if (relax_mode == "both"):
                relaxer.run(fmax=fmax, smax=smax)
            else:
                relaxer.run(fmax=fmax)
        energy = atoms.get_potential_energy()

        orig_atoms = db.get_atoms(runID)
        single_p_calc = SinglePointCalculator(orig_atoms, energy=energy)
        orig_atoms.set_calculator(single_p_calc)
        kvp = db.get(name=name).key_value_pairs
        del db[runID]
        newID = db.write(orig_atoms, key_value_pairs=kvp)

        if (relax_mode == "positions"):
            db.update(newID, converged_force=True)
        elif (relax_mode == "cell"):
            db.update(newID, converged_stress=True)
        else:
            db.update(newID, converged_stress=True, converged_force=True)

        db.update(newID, single_point=single_point)
        db.update(newID, restart_file=SaveRestartFiles.restart_name(name))
        row = db.get(id=newID)
        conv_force = row.get("converged_force", default=0)
        conv_stress = row.get("converged_stress", default=0)
        if ((conv_force == 1) and (conv_stress == 1) and (nkpt == 4)):
            db.update(newID, converged=True)
    except Exception as exc:
        print(exc)
# creates: H-MoS2_band_structure.png
from math import floor, ceil
import matplotlib.pyplot as plt
import ase.db

name = 'MoS2'
phase = 'H'

txtname = phase + '-' + name.replace('2', '$_2$')

# Connect to database
db = ase.db.connect('c2dm.db')
# Get the db row
row = db.get(name=name, phase=phase, xc='LDA')

ef = row.data['efermi'] # Fermi level
x_k = row.data['xbs_k'] # LDA band structure coordinates
e_kn = row.data['ebs_kn'] # LDA band structure energies

xqp_k = row.data['xqpbs_k'] # GW band structure coordinates
eqp_kn = row.data['qpbs_kn'] # GW band structure energies

x_K = row.data['xbs_K'] # Coordinates of high symmetry points
labels_K = row.data['bslabels_K'] # Names of high symmetry points
# Use Gamma symbol instead of 'Gamma'
for K, label in enumerate(labels_K):
    if label == 'Gamma':
        labels_K[K] = r'$\Gamma$'

ppi = 100
figw = 600 # Width in pixels
示例#18
0
def get_atomsrow_by_id(unique_id):
    db = get_ase_db()
    row = db.get('unique_id={}'.format(unique_id))
    return row
示例#19
0
文件: app.py 项目: jboes/ase
def summary(id):
    s = Summary(db.get(id), SUBSCRIPT)
    return render_template('summary.html', s=s, home=home)
示例#20
0
def summary(id):
    s = Summary(db.get(id), SUBSCRIPT)
    return render_template('summary.html', s=s, home=home)
示例#21
0
from time import time
import ase.db
from ase import Atoms

for name in ['x.json', 'x.db']:
    print(name)
    db = ase.db.connect(name, append=False)
    db.write(Atoms(), x=1, data={'a': 1})
    db.update(1, y=2, data={'b': 2})
    db.update(1, delete_keys=['x'])
    row = db.get(1)
    print(row.y, row.data)
    assert 'x' not in row
    db.update(1, atoms=Atoms('H'))
    row = db.get(1)
    print(row.y, row.data, row.numbers)
    assert (row.numbers == [1]).all()
    assert sorted(row.data) == ['a', 'b']

    db.write(Atoms(), id=1)
    row = db.get(1)
    assert len(row.data) == 0
    assert len(row.key_value_pairs) == 0
    assert len(row.numbers) == 0

    # N = 100
    N = 5
    for i in range(N):
        db.write(Atoms('H10'), i=i, data={'c': 3})

    t0 = time()
示例#22
0
    def transfer(self,
                 filename_sqlite,
                 start_id=1,
                 write_ase=True,
                 write_publication=True,
                 write_reaction=True,
                 write_reaction_system=True,
                 block_size=1000,
                 start_block=0):
        self.stdout.write('Starting transfer\n')
        con = self.connection or self._connect()
        self._initialize(con)
        self.stdout.write('Finished initialization\n')
        cur = con.cursor()
        self.stdout.write('Got a cursor\n')

        set_schema = 'SET search_path = {0};'.format(self.schema)
        cur.execute(set_schema)

        import os
        self.stdout.write('Imported os\n')
        import ase.db
        self.stdout.write('Imported ase.db\n')
        self.stdout.write('Building server_name\n')
        server_name = "postgres://{0}:{1}@{2}:5432/catalysishub".format(
            self.user, self.password, self.server)
        self.stdout.write('Connecting to {server_name}\n'.format(**locals()))

        nkvp = 0
        nrows = 0
        if write_ase:
            db = ase.db.connect(filename_sqlite)
            n_structures = db.count()
            n_blocks = int(n_structures / block_size) + 1
            for block_id in range(start_block, n_blocks):
                b0 = block_id * block_size + 1
                b1 = (block_id + 1) * block_size + 1
                self.stdout.write(
                    str(block_id) + ' ' + 'from ' + str(b0) + ' to ' +
                    str(b1) + '\n')
                if block_id + 1 == n_blocks:
                    b1 = n_structures + 1
                #rows = [db._get_row(i) for i in range(b0, b1]
                #db2 = ase.db.connect(server_name, type='postgresql')
                #for lala in [0]:
                with ase.db.connect(server_name, type='postgresql') as db2:
                    for i in range(b0, b1):
                        self.stdout.write('  .' + str(i))
                        self.stdout.flush()
                        row = db.get(i)
                        kvp = row.get('key_value_pairs', {})
                        nkvp -= len(kvp)
                        # kvp.update(add_key_value_pairs)
                        nkvp += len(kvp)
                        db2.write(row, data=row.get('data'), **kvp)
                        nrows += 1
                    self.stdout.write('\n')

                self.stdout.write('Finished Block {0}\n:'.format(block_id))
                self.stdout.write(
                    '  Completed transfer of {0} atomic structures.\n'.format(
                        nrows))

        from cathub.cathubsqlite import CathubSQLite
        db = CathubSQLite(filename_sqlite)
        con_lite = db._connect()
        cur_lite = con_lite.cursor()

        # write publication
        Npub = 0
        Npubstruc = 0
        if write_publication:
            try:
                npub = db.get_last_pub_id(cur_lite)
            except:
                npub = 1
            for id_lite in range(1, npub + 1):
                Npub += 1
                row = db.read(id=id_lite, table='publication')
                if len(row) == 0:
                    continue
                values = row[0]
                pid, pub_id = self.write_publication(values)

            # Publication structures connection
            cur_lite.execute("""SELECT * from publication_system;""")
            rows = cur_lite.fetchall()
            for row in rows:
                Npubstruc += 1
                values = row[:]
                key_str, value_str = get_key_value_str(
                    values, table='publication_system')

                set_schema = 'SET search_path = {0};'.format(self.schema)
                cur.execute(set_schema)
                print("[SET SCHEMA] {set_schema}".format(**locals()))

                insert_command = 'INSERT INTO publication_system ({0}) VALUES ({1}) ON CONFLICT DO NOTHING;'.format(
                    key_str, value_str)

                cur.execute(insert_command)
                # self.write(values, table='publication_system')
            con.commit()

        Ncat = 0
        Ncatstruc = 0

        if write_reaction:
            n = db.get_last_id(cur_lite)
            select_ase = """SELECT * from reaction_system where id={};"""
            for id_lite in range(start_id, n + 1):
                row = db.read(id_lite)
                if len(row) == 0:
                    continue
                values = row[0]

                id = self.check(values[13],
                                values[1],
                                values[6],
                                values[7],
                                values[8],
                                strict=True)
                update_rs = False

                if id is not None:
                    id = self.update(id, values)
                    self.stdout.write(
                        'Updated reaction db with row id = {}\n'.format(id))
                    update_rs = True
                else:
                    Ncat += 1
                    id = self.write(values)
                    self.stdout.write(
                        'Written to reaction db row id = {0}\n'.format(id))

                cur_lite.execute(select_ase.format(id_lite))
                rows = cur_lite.fetchall()
                if write_reaction_system:
                    if update_rs:
                        cur.execute(
                            'Delete from reaction_system where reaction_id={0}'
                            .format(id))
                    for row in rows:
                        Ncatstruc += 1
                        values = list(row)
                        if len(values) == 3:
                            values.insert(1, None)

                        values[3] = id

                        key_str, value_str = get_key_value_str(
                            values, table='reaction_system')

                        set_schema = 'SET search_path = {0};'.format(
                            self.schema)
                        cur.execute(set_schema)
                        print("[SET SCHEMA] {set_schema}".format(**locals()))

                        insert_command = 'INSERT INTO reaction_system ({0}) VALUES ({1}) ON CONFLICT DO NOTHING;'.format(
                            key_str, value_str)

                        print("[INSERT COMMAND] {insert_command}".format(
                            **locals()))
                        cur.execute(insert_command)

                con.commit()  # Commit reaction_system for each row

        for statement in tsvector_update:
            cur.execute(statement)

        if self.connection is None:
            con.commit()
            con.close()

        self.stdout.write('Inserted into:\n')
        self.stdout.write('  systems: {0}\n'.format(nrows))
        self.stdout.write('  publication: {0}\n'.format(Npub))
        self.stdout.write('  publication_system: {0}\n'.format(Npubstruc))
        self.stdout.write('  reaction: {0}\n'.format(Ncat))
        self.stdout.write('  reaction_system: {0}\n'.format(Ncatstruc))