def new_meteorite(name, group, subgroup=None,
magnetic_carriers=None, iron_content=None,
fall=False, fall_date=None,
shock_stage=None,
comment='', notes=''):
session = helper.connect_db()
res = session.query(Group).filter(Group.name == group).first()
if not res:
res = session.query(Group).filter(Group.full_name == group).first()
if res:
check = session.query(Meteorite).filter(Meteorite.name == name).first()
if check:
print '%s already in database' % check.name
return check
else:
met = Meteorite(name=name.lower(), group_id=res.id,
magnetic_carriers=None, iron_content=iron_content,
shock_stage=shock_stage,
fall=True, fall_date=fall_date,
comment=comment, notes=notes
)
session.add(met)
session.commit()
session.close()
return res
else:
print '%s not found' % group
def measurement_type(name, **kwargs):
session = helper.connect_db()
res = fetch.measurement_type(name)
if not res:
mdef = Measurement_Def(name)
mdef.comment = kwargs.get('comment')
mdef.notes = kwargs.get('notes')
mdef.reference = kwargs.get('reference')
mdef.defA = kwargs.get('defA')
mdef.defB = kwargs.get('defB')
mdef.defC = kwargs.get('defC')
mdef.defD = kwargs.get('defD')
mdef.defE = kwargs.get('defE')
mdef.defF = kwargs.get('defF')
mdef.defG = kwargs.get('defG')
mdef.defH = kwargs.get('defH')
mdef.defI = kwargs.get('defI')
mdef.defJ = kwargs.get('defJ')
mdef.defK = kwargs.get('defK')
mdef.defL = kwargs.get('defL')
mdef.defM = kwargs.get('defM')
mdef.date_added = datetime.datetime.now()
session.add(mdef)
session.commit()
return mdef
else:
return res
def measurements(sample_name, type, *args, **kwargs):
session = connect_db()
m_out = (
session.query(Measurement)
.filter(Measurement.name == sample_name)
# .filter(Measurement.measurement_type_id == measurement_type(type).id)
).all()
print m_out
return m_out
def measurement_type(type, *args, **kwargs):
session = connect_db()
measurement_type = (
session.query(Measurement_Def)
.filter(Measurement_Def.name == type)
).first()
if not measurement_type:
'%s not implemented' % type
return measurement_type
def d_def(name, defA, defB=None, defC=None, comment=None, notes=None):
session = connect_db()
res = session.query(Data_Def).filter(Data_Def.name == name).first()
if not res:
D_Type = Data_Def(name, defA, defB, defC, comment, notes)
session.add(D_Type)
else:
print res, 'already in database, please check defintion:'
print res.all()
session.commit()
def new_sample(
name,
meteorite,
intensity,
unit,
determination_type,
citekey,
intensity_error=None,
lab_field=None,
fit_t_min=None,
fit_t_max=None,
vacuum=None,
vac_unit="",
inert_gas=None,
comment="",
notes="",
):
session = helper.connect_db()
conversion = {"Oe": 0.0001, "mT": 1e-3, "muT": 1e-6, "torr": 133.322368, "": 1} # to Tesla # pascal
if isinstance(meteorite, Meteorite):
met_id = meteorite.id
else:
res = session.query(Meteorite).filter(Meteorite.name == meteorite).first()
if res:
met_id = res.id
check = session.query(Sample).filter(Sample.name == name).first()
# try:
# Pint_T = intensity*conversion[unit]
if not check:
sample = Sample(
name=name,
meteorite_id=met_id,
intensity=intensity * conversion[unit],
intensity_error=intensity_error * conversion[unit],
determination_type=determination_type,
citekey=citekey,
vacuum=vacuum * conversion[vac_unit],
inert_gas=inert_gas,
fit_t_min=fit_t_min,
fit_t_max=fit_t_max,
lab_field=lab_field * conversion[unit],
comment=comment,
notes=notes,
)
session.add(sample)
session.commit()
session.close()
return sample
def show(project, s_set=None, samples='all'):
session = connect_db()
table = []
if samples == 'all':
set = session.query(SampleSet).filter(SampleSet.name == s_set).first()
res = (
session.query(Sample)
# .join(SampleSet) # It's necessary to join the "children" of Post
.filter(Project.name == project)
# here comes the magic:
# you can filter with Tag, even though it was not directly joined)
.filter(Sample.sample_set.contains(set))
).all()
for S in res:
print S.name
print '-------------'
d = None
mass_measurements = (
session.query(Measurement)
.filter(Measurement.sample_id == S.id)
.filter(Measurement.name == 'mass')
).all()
height_measurements = (
session.query(Measurement)
.filter(Measurement.sample_id == S.id)
.filter(Measurement.name == 'height')
).all()
diameter_measurements = (
session.query(Measurement)
.filter(Measurement.sample_id == S.id)
.filter(Measurement.name == 'diameter')
).all()
for measurement in mass_measurements:
mass_point = (
session.query(Data_Point)
.filter(Data_Point.measurement_id == measurement.id)
).all()
for point in mass_point:
# print point.id
d = (session.query(Data)
.filter(Data.data_point_id == point.id).filter(Data.data_type_id == 1)).all()
# print d
masses = [i.valA for i in d if type(i.valA)==float ]
mass = np.mean(masses)
print S.name, measurement.name, measurement.date_added, mass
def exp_def(name, defA=None, defB=None, defC=None, exp_class=None, comment=None, notes=None, references=None):
''' logging '''
log = logging.getLogger(name='RockPy.experiments')
log.debug('ESTABLISHING CONNECTION to database')
session = connect_db()
log.debug('TRYING \t to create new experiment definition << %s >>' % name)
res = session.query(Experiment_Def).filter(Experiment_Def.name == name).first()
if not res:
e_def = Experiment_Def(name=name, defA=defA, defB=defB, defC=defC,
exp_class=exp_class, comment=comment, notes=notes, references=references)
log.info('SUCCESS \t new experiment definition << %s >> created' % name)
session.add(e_def)
if res:
log.warning('FAIL \t << %s >>already in database, please check defintion!' % res)
session.commit()
session.close()
def meas_def(name, comment='', notes='', references='', measurement_class=None,
defA=None, defB=None, defC=None, defD=None, defE=None, defF=None, defG=None, defH=None,
defI=None, defJ=None, defK=None, defL=None, defM=None, defN=None, defO=None, defP=None,
defQ=None, defR=None, defS=None, defT=None, defU=None, defV=None, defW=None, defX=None,
defY=None, defZ=None):
log = logging.getLogger(name='RockPy.measurements')
log.debug('ESTABLISHING CONNECTION to database')
session = connect_db()
log.debug('TRYING \t to create new measurement definition << %s >>' % name)
res = session.query(Measurement_Def).filter(Measurement_Def.name == name).first()
if not res:
e_def = Measurement_Def(name=name, comment=comment, notes=notes, measurement_class=measurement_class,
defA=defA, defB=defB, defC=defC, defD=defD, defE=defE, defF=defF, defG=defG, defH=defH,
defI=defI, defJ=defJ, defK=defK, defL=defL, defM=defM, defN=defN, defO=defO, defP=defP,
defQ=defQ, defR=defR, defS=defS, defT=defT, defU=defU, defV=defV, defW=defW, defX=defX,
defY=defY, defZ=defZ)
log.info('SUCCESS \t new measurement definition << %s >> created' % name)
session.add(e_def)
if res:
log.warning('FAIL \t << %s >> already in database, please check definition!' % res)
session.commit()
session.close()
import sys
import pymongo
import time
import requests
import helper
# author: Mario Schuetz
#
# Process heatmap requests
#
db = helper.connect_db('Heatmap')
# used for heatmap
def hm_query(collection, query):
start = time.time()
print(f'Searching for {query} in {collection}')
results = list(db[collection].find(query, {
'_id': 1,
'zip': 1,
'city': 1,
'area_code': 1
}))
if results is None or len(results) <= 0:
print('Found 0 results')
return []
print(f'Found {len(results)} results')
results = sort_results_by_zip_and_city(results)
print('Geocoding...')
geo_list = []
for r in results:
notes = Column(String(250))
intensity = Column(Float) # always stored in T
intensity_error = Column(Float) # always stored in T
lab_field = Column(Float) # always stored in T
fit_t_min = Column(Float)
fit_t_max = Column(Float)
determination_type = Column(String(250))
citekey = Column(String(250))
vacuum = Column(String(250))
inert_gas = Column(String(250))
engine = create_engine('sqlite:///meteorite_intensity.db')
# engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
session = helper.connect_db()
''' Kingdoms '''
diff = Kingdom(name='differentiated')
undiff = Kingdom(name='undifferentiated')
general = Kingdom(name='no kingdom')
map(session.add, [diff, undiff, general])
session.commit()
''' Categories '''
chondr = Cat(name='chondrites', kingdom_id=undiff.id)
primitive_achondr = Cat(name='primitive achondrites', kingdom_id=diff.id)
achondr = Cat(name='achondrites', kingdom_id=general.id)
map(session.add, [chondr, achondr, primitive_achondr])
session.commit()
session.flush()
def sample_mass_dimensions(file, project, experiment, *args, **kwargs):
"""
Import of Sample mass and dimension CSV files.
:param:
file: *str*
project: *str*
experiment: *str*
:kwargs:
mass_unit: *str* can specify the unit e.g. 'mg'
length_unit: *str* can specify the unit for diameter and height e.g. 'mm'
:filestructure:
HEADER
DATA
:datastructure:
Header:
Sample \t mass \t height \t diameter
:Data:
Ia \t 435.2 \t 21.5 \t 23
""" # Todo rewrite the info
experiment_type = "mass & dimensions"
db = kwargs.get("db")
natural = kwargs.get("natural")
readall = reader(open(file), delimiter="\t")
readall.next()
mass_unit = kwargs.get("mass_unit")
length_unit = kwargs.get("length_unit")
s_set = kwargs.get("sample_set")
entries = []
for row in readall: # Loop over rows of csv file
sample = row[0]
mass = float(row[1])
height = float(row[2])
diameter = float(row[3])
aux = [sample, mass, height, diameter]
entries.append(aux)
# print row
if db:
session = helper.connect_db()
project = helper.check_project(session, project)
experiment = add.experiment(session=session, name=experiment, definition="mass & dimensions")
if s_set:
sample_set = add.sample_set(session, s_set)
for sample in entries:
if project:
sample_obj = add.sample(session=session, name=sample[0], project_id=project.id)
if s_set:
sample_set.samples.append(sample_obj)
measurement = add.measurement(
session=session,
name="mass",
definition="mass & dimensions",
sample=sample_obj,
experiment=experiment,
mtype="mass",
)
data_point = add.data_point(session, sample, measurement)
data = helper.input_data(session, data_point, data=sample, definition="mass")
measurement2 = add.measurement(
session=session,
name="height",
definition="mass & dimensions",
sample=sample_obj,
experiment=experiment,
)
data_point2 = add.data_point(session, sample, measurement2)
data2 = helper.input_data(
session, data_point2, data=sample, definition="height", unit="mm", unit_type="length"
)
measurement3 = add.measurement(
session=session,
name="diameter",
definition="mass & dimensions",
sample=sample_obj,
experiment=experiment,
)
data_point3 = add.data_point(session, sample, measurement3)
data3 = helper.input_data(
session, data_point3, data=sample, definition="diameter", unit="mm", unit_type="length"
)
def main():
sess = connect_db('../../locations')
