def main(args): # data = make_circles(100, shuffle=True)[0] # data = ReadPlyFile('data/bun000.ply').get_data() data = ReadPlyFile('data/drill_1.6mm_0_cyb.ply').get_data() # data = ReadPlyFile('data/dragonStandRight_0.ply').get_data() # print(len(data)) def filter_norm(point): return np.linalg.norm(point - np.array(data).min(0)) def filter_x(point): return point[0] mapper = Mapper(data, resolution=0.2, overlap=0.4, cluster_alg='kmeans', max_clusters=5, filter=filter_norm) graph = mapper.run() print(graph) viz = Visualization(graph) viz.draw(36, 3000) persistence = Persistence(graph) persistence.draw()
def __init__(self, logger=None): self._rf = RF_Sender() self._logger = logger if self._logger == None: self._logger = Logger('Pump', Logger.INFO, "/home/pi/MVP/logs/obsv.log") self._persist = Persistence(self._logger)
def test_request(self): persistence = Persistence('test.db') now = datetime.utcnow().replace(microsecond=0) dt0 = now - timedelta(seconds=30) persistence.store(dt0, 100.0, 100.0, 100.0, 100.0) service = Service(persistence) response = service.request(self.start_response) self.assertEqual( response.next(), 'data: {"dest": "archive", "items": [], "type": "preload"}\n\n') self.assertEqual( response.next(), 'data: {"dest": "recent", "items": [{"dt": "%sZ", "humidity": 100.0, "temperature": 100.0, "moisture": 100.0, "luminence": 100.0}], "type": "preload"}\n\n' % dt0.isoformat()) dt1 = now service.enqueue('recent', 'realtime', [{ 'dt': dt1, 'moisture': 200.0, 'luminence': 200.0, 'temperature': 200.0, 'humidity': 200.0 }]) self.assertEqual( response.next(), 'data: {"dest": "recent", "items": [{"dt": "%sZ", "humidity": 200.0, "temperature": 200.0, "moisture": 200.0, "luminence": 200.0}], "type": "realtime"}\n\n' % dt1.isoformat())
def __init__(self, logger=None): self._logger = logger if self._logger == None: self._logger = Logger('Light', Logger.INFO, "/home/pi/MVP/logs/obsv.log") self._logger.debug("Initialize RF Light") self._rf = RF_Sender(self._logger) self._persist = Persistence(self._logger)
def add_query(): query_name = request.form.get('query name') query = request.form.get('query') Persistence.add_query(query_name, query) flash("Added query") return redirect(url_for('display_statistics'))
def __init__(self): '''Get distances for determining reservoir levels''' self.res = {'full': full_ec, 'empty': empty_ec, 'timeout': timeout} self._activity_type = 'Agronomic_Activity' self._logger = Logger('LogReservoir', Logger.INFO) self._persist = Persistence(self._logger) self._logger.detail("Reservoir Initialized") # flag for testing self._test = False
def __init__(self, logger=None): self._logger = logger if logger == None: self._logger = Logger("Relay", Logger.INFO) self._logger.debug("initialize Fan object") self._relay = Relay(self._logger) self.fan_relay = FAN_PIN self._persist = Persistence(self._logger) # flag for testing self._test = False
def update_query(): new_name = request.form.get('query name') new_query = request.form.get('query') old_name = request.form.get('orig query name') old_query = request.form.get('orig query') if old_name != new_name: Persistence.update_query_name(old_name, new_name) if old_query != new_query: Persistence.update_query_query(new_name, new_query) flash('Updated query') return redirect(url_for('display_statistics'))
def __init__(self, lvl=Logger.INFO): """Record optional sensor data Args: lvl: Logging level Returns: None Raises: None """ self._logger = Logger("LogSensor-Extra", lvl, file="/home/pi/MVP/logs/obsv.log") self._activity_type = "Environment_Observation" self._test = False self._persist = Persistence(self._logger)
def main(): persistence = Persistence() env = BitEnvironment() direct = [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]] terminal, step_count, e, success, = False, 0, 0, 0 obes = [] for i in range(0, 80): obes.append([random.randint(0, 99), random.randint(0, 99)]) env.setObstacle(obes) while True: #direction = random.randint(0, 7) # 包含两个,01方向减法,23上次速度 direction = env.getNextStep() Position, move = env.step(direction) env.preDirect = direct[direction] print("行动否:{} 具体行动方向: {} 当前位置 {}".format(move, direct[direction], Position)) dist, realDirect = env.distToTarget() print("距离目标: {} 目标方位: {}".format(dist, realDirect)) if env.judgeCollision() or env.done(): terminal = True step_count += 1 print("阶段 {} 完成, 总成功: {} 当轮步数: {}".format(e, success, step_count)) env.showimage() if terminal: if env.done(): success += 1 print( "-----------------------------success----------------------------------" ) elif env.judgeCollision(): print( "-----------------------------发生碰撞----------------------------------" ) step_count = 0 e += 1 infoShow = "time {}, episode {} finish, total success: {} step: {}".format( time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())), e, success, step_count) persistence.saveTerminalRecord("GoInBitMap", infoShow) env.reset([random.randint(0, 99), random.randint(0, 99)]) env.setObstacle(obes) terminal = False time.sleep(0.2)
def handler(): """postfork hanlder, creates global domain object""" global domain persistence = Persistence('tve.db') acquisition = Acquisition('/dev/ttyACM0') service = Service(persistence) domain = Domain(persistence, acquisition, service) logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s') logging.info('Domain object initialized')
class Light(object): def __init__(self, logger=None): self._logger = logger if self._logger == None: self._logger = Logger('Light', Logger.INFO, "/home/pi/MVP/logs/obsv.log") self._logger.debug("Initialize RF Light") self._rf = RF_Sender(self._logger) self._persist = Persistence(self._logger) def __del__(self): self._rf.cleanup() def set_on(self, test=False): "Check state and turn on if needed" self._rf.set_on(lightPin, ) self.log_state("On", test) self._logger.debug('Light turned ON') def set_off(self, test=False): '''Check state and turn off if needed''' self._rf.set_off(lightPin) self.log_state("Off", test) self._logger.debug('Light turned Off') def log_state(self, value, test=False): """ Create Environment Observation """ status_qualifier = 'Success' if test: status_qualifier = 'Test' self._persist.save([ 'State_Change', '', 'Top', 'Lights', 'State', value, 'Boolean', 'Light', status_qualifier, '' ]) def check(self): env = Environ(self._logger) if env._state: self.set_on(test) else: self.set_off(test)
class Pump(object): def __init__(self, logger=None): self._rf = RF_Sender() self._logger = logger if self._logger == None: self._logger = Logger('Pump', Logger.INFO, "/home/pi/MVP/logs/obsv.log") self._persist = Persistence(self._logger) def __del__(self): ''' Don't call GPIO.cleanup() as need to leave pin state as is ''' pass def on(self, test=False): "Check state and turn on if needed" self._rf.set_on(pumpPin, ) self.log_state("On", test) self._logger.debug('Pump turned ON') def off(self, test=False): '''Check state and turn off if needed''' self._rf.set_off(pumpPin) self.log_state("Off", test) self._logger.debug('Pump turned Off') def log_state(self, value, test=False): """ Create Environment Observation """ status_qualifier = 'Success' if test: status_qualifier = 'Test' self._persist.save([ 'State_Change', '', 'Reservoir', 'Pump', 'State', value, 'Pump', 'state', status_qualifier, '' ])
minR = 0.1e-9 maxR = 50e-9 fileBase = './' outDir = './' outFile = open(outDir + 'deformation.dat', 'w') forceFile = open(outDir + 'force.dat', 'w') restartFileName = outDir + 'restart.hdf5' restartFileName = '' saveFileName = outDir + 'checkpoint.hdf5' if restartFileName != '': print 'I am restarting......' restartFile = Persistence(restartFileName, 'r') else: restartFile = None solidCaseFile = fileBase + 'Gen5_beam_2D.cas' fluidCaseFile = fileBase + 'fluid_electrode_dielectric.cas' fluidReader = FluentCase(sys.argv[1]) solidReader = FluentCase(sys.argv[2]) fluidReader.read() solidReader.read() fluidMeshes = fluidReader.getMeshList() fluidMeshesOrig = fluidMeshes solidMeshes = solidReader.getMeshList()
def saveRestartFile(self, outDir, n): saveFileName = outDir + 'checkpoint_' + str(n) + '.hdf5' f = Persistence(saveFileName,'w') f.saveAttribute('globalCount', self.globalCount) f.saveAttribute('globalTime', self.globalTime) ts = self.timeStep tsN1 = self.poptions.timeStepN1 tsN2 = self.poptions.timeStepN2 f.saveAttribute('timeStep', ts) f.saveAttribute('timeStepN1', tsN1) f.saveAttribute('timeStepN2', tsN2) f.saveFluidMeshes(self.fluidMeshes) f.saveSolidMeshes(self.solidMeshes) f.savePlateModel(self.plateFields,self.pmodel,self.solidMeshes) f.saveElectricModel(self.elecFields,self.emodel,self.fluidMeshes) f.close()
def select_database(self, name): Persistence.select_database(self, name) self.init()
from Pesos import Pesos from Atributos import Atributos from Casos import Casos from Persistence import Persistence if __name__ == "__main__": # executar uma vez para popular o banco de dados, após seguir os passos do README dbHandler: Persistence = Persistence() dbHandler.createSchema() pesos: Pesos = Pesos("pesos.csv") atributos: Atributos = Atributos("atributos.csv") casos: Casos = Casos("casos.csv") pesos.persist() atributos.persist() casos.persist() print( "\x1b[1m\x1b[5m\x1b[32mO Banco de dados foi criado com sucesso!!!\x1b[0m" )
class TestPersistence(unittest.TestCase): def setUp(self): self.persistence = Persistence('test.db') def tearDown(self): if os.path.exists('test.db'): os.remove('test.db') def test_init(self): self.assertEqual(os.path.exists('test.db'), True) def test_historical(self): now = datetime.utcnow().replace(microsecond=0) dt0 = now - timedelta(seconds=120) dt1 = now - timedelta(seconds=30) dt2 = now - timedelta(seconds=15) self.persistence.store(dt0, 0.1, 0.1, 0.1, 0.1) self.persistence.store(dt1, 0.2, 0.2, 0.2, 0.2) self.persistence.store(dt2, 0.3, 0.3, 0.3, 0.3) result = self.persistence.historical(60) expected = [{ 'dt': dt1, 'moisture': 0.2, 'luminence': 0.2, 'temperature': 0.2, 'humidity': 0.2 }, { 'dt': dt2, 'moisture': 0.3, 'luminence': 0.3, 'temperature': 0.3, 'humidity': 0.3 }] self.assertEqual(result, expected) def test_historical_archive(self): now = datetime.utcnow().replace(minute=0, second=0, microsecond=0) dt0 = now - timedelta(minutes=80) dt1 = now - timedelta(minutes=70) dt2 = now - timedelta(minutes=30) self.persistence.store(dt0, 0.0, 0.0, 0.0, 0.0) self.persistence.store(dt1, 0.2, 0.2, 0.2, 0.2) self.persistence.store(dt2, 0.3, 0.3, 0.3, 0.3) expected = [ { 'dt': dt1.replace(minute=0), 'moisture': 0.1, 'luminence': 0.1, 'temperature': 0.1, 'humidity': 0.1 }, { 'dt': dt2.replace(minute=0), 'moisture': 0.3, 'luminence': 0.3, 'temperature': 0.3, 'humidity': 0.3 }, ] self.persistence.archive() result = self.persistence.historical_archive(3) self.assertEqual(result, expected)
muref= 2.117e-5; mu_w=0.81; molecularWeight=39.9; elif (gas == 'Nitrogen'): Pr=3.0/4.0; SpHeatRatio=7.0/5.0; muref= 1.781e-5; mu_w=0.74; molecularWeight=28.0; print ' Pr= ',Pr,' muref= ',muref u_init=(2.0*8314.0*T_init/molecularWeight)**0.5 uwall=10.0/u_init; if restartFileName != "": restartFile = Persistence(restartFileName,'r') else: restartFile = None # to test quadrature import fvm.esbgk_atyped_double as esbgk #facegroups fgs = meshes[0].getBoundaryFaceGroups() for fg in fgs: #print fg.groupType if fg.id == 4 or fg.id == 6: fg.groupType = "realwall" print fg.id," ",fg.groupType #Quadrature quad0=esbgk.QuadratureD(10,10,10,5.5,1.0) #cartesian
class Fan(object): """Code associated with the exhaust fan""" ON = 1 OFF = 0 target_temp = 0 def __init__(self, logger=None): self._logger = logger if logger == None: self._logger = Logger("Relay", Logger.INFO) self._logger.debug("initialize Fan object") self._relay = Relay(self._logger) self.fan_relay = FAN_PIN self._persist = Persistence(self._logger) # flag for testing self._test = False def set(self, state): """Set the fan to state Args: state: condition from other source Returns: None Raises: None """ self._logger.debug("In set_state") prior = self._relay.get_state(self.fan_relay) self._relay.set_state(self.fan_relay, state) current = self._relay.get_state(self.fan_relay) if prior != current: self.log_state(state) def set_fan_on(self): """Turn the fan on Args: None Returns: None Raises: None """ self._logger.debug("In set_fan_on") self.set(ON, test) def set_fan_off(self): """Turn the fan off Args: None Returns: None Raises: None """ self._logger.debug("In set_fan_off") self.set(OFF, test) def log_state(self, value): """Send state change to database Args: value: state change (numeric value) test: flag for testing Returns: None Raises: None """ state = 'Off' if value > 0: state = 'On' status_qualifier = 'Success' if self._test: status_qualifier = 'Test' self._persist.save([ 'State_Change', '', 'Side', 'Fan', 'State', state, 'Boolean', 'Fan', status_qualifier, '' ]) self._logger.debug("{}, {:1}, {} {}".format( "Fan State Change: Value: ", value, " Status Qualifier: ", status_qualifier)) def getState(self): return self._relay.get_state(self.fan_relay)
def main(): env = drone_env_heightcontrol(aim=None) state = env.reset() state_shape = 4 action_bound = 1 action_dim = 2 e, success, episode_reward, step_count = 0, 0, 0, 0 persistence = Persistence() if choose == "1": infoShow = "time {}, start new train, method{}".format( time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())), "DDPG") persistence.saveTerminalRecord("DDPG", infoShow) with tf.device("/gpu:0"): config = tf.ConfigProto( allow_soft_placement=True ) # tf.ConfigProto()函数用在创建session的时候,用来对session进行参数配置 config.gpu_options.allow_growth = True # 当allow_growth设置为True时,分配器将不会指定所有的GPU内存,而是根据需求增长 with tf.Session(config=config) as sess: globe_episode = tf.Variable( 0, dtype=tf.int32, trainable=False, name='globe_episode' ) # 设定trainable=False 可以防止该变量被数据流图的 GraphKeys.TRAINABLE_VARIABLES 收集, # 这样我们就不会在训练的时候尝试更新它的值。 agent = DDPG_agent(sess, state_shape, action_bound, action_dim) saver = tf.train.Saver(var_list=tf.global_variables()) print(DIR) if not agent.load(saver, DIR): sess.run(tf.global_variables_initializer()) if not os.path.exists(DIR): os.mkdir(DIR) else: print("coninnue------------------") if PREMODEL: prepath = os.path.join(PATH, 'premodel\checkpoint') ckpt = tf.train.get_checkpoint_state( os.path.dirname(prepath)) if ckpt and ckpt.model_checkpoint_path: saver.restore(agent.sess, ckpt.model_checkpoint_path) agent.action_noise.reset() print( "------------pretrained model loaded-------------") while True: print(state[1]) action = agent.act(state) next_state, reward, terminal, info = env.step(action) episode_reward += reward agent.observe(state, action, reward, next_state, terminal) agent.train() state = next_state ''' if train%10==0: print("total training episode: {}".format(train)) print("--------------------------------------------------------------------") if train%10000==0: nDir = os.path.join(PATH, "data/" + str(int(train // 10000))) if not os.path.exists(nDir): os.mkdir(nDir) agent.save(saver, nDir) print("save") print("--------------------------------------------------------------------") train+=1 ''' step_count += 1 print("aim height: {}".format(env.aim_height).ljust( 20, " "), "reward: {:.5f}.".format(reward).ljust(20, " "), "steps: {}".format(step_count).ljust(20, " "), end="\r") if terminal: if info == "success": success += 1 print(" " * 80, end="\r") print( "episode {} finish, average reward: {:.5f}, total success: {} result: {} step: {}" .format(e, step_count).ljust(80, " ")) episode_reward = 0 step_count = 0 e += 1 total_episode = sess.run(globe_episode.assign_add(1)) if e % 10 == 0: nDir = os.path.join(PATH, "data/" + str(int(e // 10))) if not os.path.exists(nDir): os.mkdir(nDir) agent.save(saver, nDir, DIR) print("total training episode: {}".format( total_episode)) infoShow = "time {}, episode {} finish, total success: {} step: {}".format( time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())), e, success, step_count) persistence.saveTerminalRecord("DDPG", infoShow) state = env.reset() return elif choose == "2": agent = EnergyAgent(state_shape, action_bound, action_dim) infoShow = "time {}, start new train, method{}".format( time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())), "EnergyAgent") persistence.saveTerminalRecord("EnergyAgent", infoShow) while True: # 包含两个,01方向减法,23上次速度 print("目标相对位置,目前位移方向: {} ".format(state[1])) action = agent.act(state) print("具体方向: {} ".format(action)) next_state, reward, terminal, info = env.step(action) state = next_state step_count += 1 print("阶段 {} 完成, 总成功: {} 当轮步数: {}".format(e, success, step_count)) if terminal: if info == "success": success += 1 print( "-----------------------------success----------------------------------" ) step_count = 0 e += 1 infoShow = "time {}, episode {} finish, total success: {} step: {}".format( time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())), e, success, step_count) persistence.saveTerminalRecord("EnergyAgent", infoShow) state = env.reset() else: print("仿真结束") return
def display_statistics(): queries = Persistence.get_statistics() return render_template("statistics.html", queries=queries)
def __init__(self): Persistence.__init__(self)
def get_ids(self, limit=-1, idx=0): return Persistence.get_keys(self, limit, idx)
class Reservoir: FULL = 0 EMPTY = 1 OK = 2 vol_per_mm = 0.3785 # estimate 1 gal per 10 mm, this is reservoir specific vol_per_sec = 0.3785 # estimate 100 ml per sec, this is reservoir specific def __init__(self): '''Get distances for determining reservoir levels''' self.res = {'full': full_ec, 'empty': empty_ec, 'timeout': timeout} self._activity_type = 'Agronomic_Activity' self._logger = Logger('LogReservoir', Logger.INFO) self._persist = Persistence(self._logger) self._logger.detail("Reservoir Initialized") # flag for testing self._test = False def getStatus(self): "Logic for calling the reservoir full" self._logger.detail("In getStatus") ec = self.getEC() if ec <= full_ec: self._logger.debug("{}, {}, {:10.1f}".format( "Reservoir Full", EC, ec)) return Reservoir.FULL, ec elif ec >= empty_ec: self._logger.debug("{}, {}, {:10.1f}".format( "Reservoir Empty", EC, ec)) return Reservoir.EMPTY, ec else: self._logger.debug("{}, {}, {:10.1f}".format( "Reservoir not Empty", EC, ec)) return Reservoir.OK, ec def isFull(self): self._logger.detail("In isFull") status, ec = self.getStatus() if status == Reservoir.FULL: return True else: return False def getEC(self): '''Get EC reading''' self._logger.detail("In getEC") snsr = EC(self._logger) return snsr.getEC() def fill(self, test=False): ''' Routine to control re-filling of the reservoir''' self._logger.detail("{}".format("In Fill")) start_ec = self.getEC() start_t = time.time() pump = Pump() pump.on() # Loop till filled or times out while (not self.isFull()) and self.isFilling(start_t): self._logger.detail("{}".format("In Fill Loop")) self._logger.detail("{}".format("Exit Fill Loop, close solenoid")) # Close valve pump.off() # Calculate amount filled stop_t = time.time() stop_ec = self.getEC() dif_t = stop_t - start_t volume = dif_t * self.vol_per_sec self._logger.detail("{}".format("Exit Fill")) return volume def isFilling(self, start_time, test=False): '''Check that actually filling: the distance is actually changing''' start_ec = self.getEC() self._logger.detail("{} {}".format("Filling, Start EC:", start_ec)) time.sleep(fill_time) # Check for level change first, else will never get to this logic till timeout end_ec = self.getEC() change = start_ec - end_ec if end_ec < start_ec: # need to see at least a 5mm change self._logger.detail("{} {} {} {} {} {}".format( "Still Filling, change:", change, "Start", start_ec, "End", end_ec)) return True else: self._logger.detail("{} {} {} {} {} {}".format( "Not Filling, no change:", change, "Start", start_ec, "End", end_ec)) return False # Check for timeout stop_time = time.time() if stop_time - start_time > self.res['timeout']: self._logger.detail("{}".format("Timeout")) return False else: return True def checkReservoir(self): '''Check condition of reservoir and fill if necessary''' self._logger.detail("{}".format("Check Reservoir")) status, ec = self.getStatus() self._logger.debug("{} {} {} {}".format("Status:", status, "EC", ec)) # Is full, log state if status == Reservoir.FULL: self._logger.detail("{}".format("Status: Full")) self._logger.info("{} {} {} {}".format("EC:", ec, "Full level:", self.res['full'], "Empty:", self.res['empty'])) return True else: # Needs filling self._logger.debug("{}".format("Status: Filling")) volume = self.fill() if volume > 0: # Filled, log volume self.logState(volume, 'Success') return True else: # Failure self._logger.debug("{}".format("Status: Failure")) level = 'Empty' if status == '2': level = 'Ok' self._logger.error("{}".format("Failure to fill Reservoir")) self._logger.error("{} {} {} {}".format( "EC:", ec, "Full level:", self.res['full'], "Empty:", self.res['empty'])) self.logState(volume, 'Failure') return False def logState(self, value, status_qualifier): if self._test: status_qualifier = 'Test' txt = { 'Volume': value, 'full_level': self.res['full'], 'empty_level': self.res['empty'], 'status': 'Full' } self._persist.save([ 'State_Change', '', 'Nutrient', 'Reservoir', 'Volume', value, 'Liter', 'Solenoid', status_qualifier, '' ]) self._logger.info(txt)
def update_database(): Persistence.update(session['id']) flash("Database has been updated!") return redirect(url_for('main'))
def main(): if 'id' in session: Persistence.set_user(User.get(session['id'])) return render_template("main.html")
def __init__(self, filename: str): self.filename: str = filename self.dbHandler: Persistence = Persistence()
def fetchData(tablename: str) -> list: dbHandler: Persistence = Persistence() dbHandler.connect() data: list = dbHandler.fetchAtributos(tablename) dbHandler.closeConnection() return data
def setUp(self): self.persistence = Persistence('test.db')
class LogSensorsExtra(object): def __init__(self, lvl=Logger.INFO): """Record optional sensor data Args: lvl: Logging level Returns: None Raises: None """ self._logger = Logger("LogSensor-Extra", lvl, file="/home/pi/MVP/logs/obsv.log") self._activity_type = "Environment_Observation" self._test = False self._persist = Persistence(self._logger) def getOneWire(self, test=False): """Loop OneWire temperature sensors Assumes there are four Args: test: flag for testing Returns: None Raises: None """ self._logger.debug("In getOneWire") from OneWireTemp import OneWireTemp for sensor in OneWireTemp.one_temp: self.logOneWire(sensor, OneWireTemp.one_temp[sensor]) def logOneWire(self, sensor, name, test=False): """Record OneWire temperature sensor Args: sensor: number of the sensor name: name of the sensor test: flag for testing Returns: None Raises: None """ self._logger.debug("In logOneWire") from OneWireTemp import OneWireTemp try: ow = OneWireTemp() temp = ow.getTempC(sensor) status_qualifier = 'Success' if self._test: status_qualifier = 'Test' rec = [ self._activity_type, '', name, 'Air', 'Temperature', "{:10.1f}".format(temp), 'Centigrade', 'DS18B20-' + str(sensor), status_qualifier, '' ] self._persist.save(rec) self._logger.info("{}, {}, {:10.1f}".format( name, status_qualifier, temp)) except Exception as e: status_qualifier = 'Failure' if test: status_qualifier = 'Test' rec = [ self._activity_type, '', name, 'Air', 'Temperature', '', 'Centigrade', 'DS18B20-' + str(sensor), status_qualifier, str(e) ] self._persist.save(rec) self._logger.error("{}, {}, {}".format(name, status_qualifier, e)) def getLux(self, test=False): """Record LUX sensor (TSL2561) Args: test: flag for testing Returns: None Raises: None """ from TSL2561 import TSL2561 lx = TSL2561() self._logger.info("TSL2561 - LUX") try: lux = lx.getLux() status_qualifier = 'Success' if test: status_qualifier = 'Test' rec = [ self._activity_type, '', 'Canopy', 'Light', 'LUX', "{:3.1f}".format(lux), 'lux', 'TSL2561', status_qualifier, '' ] self._persist.save(rec) self._logger.info("{}, {}, {:10.1f}".format( "LUX", status_qualifier, lux)) except Exception as e: status_qualifier = 'Failure' if test: status_qualifier = 'Test' rec = [ self._activity_type, '', 'Canopy', 'Light', 'LUX', '', 'lux', 'TSL2561', status_qualifier, str(e) ] self._persist.save(rec) self._logger.error("{}, {}, {}".format("LUX", status_qualifier, e)) def getEC(self, test=False): """Record EC sensor (EC - ADC reading) Args: test: flag for testing Returns: None Raises: None """ from EC import EC self._logger.info("EC") try: s = EC() ec = s.getEC() status_qualifier = 'Success' if test: status_qualifier = 'Test' print("{}, {}, {:10.1f}".format("EC", status_qualifier, ec)) rec = [ self._activity_type, '', 'Reservoir', 'Nutrient', 'EC', "{:3.1f}".format(ec), 'EC', 'EC', status_qualifier, '' ] self._persist.save(rec) self._logger.info("{}, {}, {:10.1f}".format( "EC", status_qualifier, ec)) except Exception as e: status_qualifier = 'Failure' if test: status_qualifier = 'Test' print("{}, {}, {:10.1f}".format("EC", status_qualifier, ec)) rec = [ self._activity_type, '', 'Reservoir', 'Nutrient', 'EC', '', 'EC', 'EC', status_qualifier, str(e) ] self._persist.save(rec) self._logger.error("{}, {}, {}".format("EC CCS811", status_qualifier, e)) def getCO2_NDIR(self, test=False): """Record CO2 sensor (NDIR) Args: test: flag for testing Returns: None Raises: None """ from NDIR import Sensor self._logger.info("CO2 - NDIR") try: sensor = Sensor() sensor.begin() co2 = sensor.getCO2() status_qualifier = 'Success' if test: status_qualifier = 'Test' print("{}, {}, {:10.1f}".format("CO2 Canopy", status_qualifier, co2)) rec = [ self._activity_type, '', 'Canopy', 'Air', 'CO2', "{:3.1f}".format(co2), 'ppm', 'MH-Z16-NDIR', status_qualifier, '' ] self._persist.save(rec) self._logger.debug("{}, {}, {:10.1f}".format( "CO2", status_qualifier, co2)) except Exception as e: status_qualifier = 'Failure' if test: status_qualifier = 'Test' print("{}, {}, {:10.1f}".format("CO2 Canopy", status_qualifier, co2)) rec = [ self._activity_type, '', 'Canopy', 'Air', 'CO2', '', 'ppm', 'MH-Z16-NDIR', status_qualifier, str(e) ] self._persist.save(rec) self._logger.error("{}, {}, {}".format("CO2 NDIR", status_qualifier, e)) def getCO2_CCS811(self, test=False): """Record CO2 sensor (CCS811) Args: test: flag for testing Returns: None Raises: None """ from CCS811 import CCS811 self._logger.info("CO2 CCS811") try: sensor = CCS811(SLAVE) co2 = sensor.get_co2() status_qualifier = 'Success' if test: status_qualifier = 'Test' print("{}, {}, {:10.1f}".format("CO2 Canopy", status_qualifier, co2)) rec = [ self._activity_type, '', 'Canopy', 'Air', 'CO2', "{:3.1f}".format(co2), 'ppm', 'CCS811', str(e) ] self._persist.save(rec) self._logger.debug("{}, {}, {:10.1f}".format( "CCS811 - CO2", status_qualifier, co2)) except Exception as e: status_qualifier = 'Failure' if test: status_qualifier = 'Test' print("{}, {}, {:10.1f}".format("CO2 Canopy", status_qualifier, co2)) rec = [ self._activity_type, '', 'Canopy', 'Air', 'CO2', '', 'ppm', 'CCS811', status_qualifier, str(e) ] self._persist.save(rec) self._logger.error("{}, {}, {}".format("CO2 CCS811", status_qualifier, e)) def getSCD(self): """Record CO2 sensor (scd30) Generates co2, temperature and relative humidity Args: None Returns: None Raises: None """ from scd30 import SCD30 self._scd = SCD30(self._logger) self._logger.debug("In SCD30") try: co2, temp, rh = self._scd.get_data() status = 'Success' if self._test: status = 'Test' c_rec = [ 'Environment_Observation', '', 'Top', 'Air', 'CO2', "{:10.1f}".format(co2), 'ppm', 'scd30', status, '' ] t_rec = [ 'Environment_Observation', '', 'Top', 'Air', 'Temperature', "{:10.1f}".format(temp), 'Centigrade', 'scd30', status, '' ] h_rec = [ 'Environment_Observation', '', 'Top', 'Air', 'Humidity', "{:10.1f}".format(rh), 'Percent', 'scd30', status, '' ] self._persist.save(c_rec) self._persist.save(t_rec) self._persist.save(h_rec) self._logger.info("{} {:6.1f}, {} {:3.1f}, {} {:3.1f}".format( "EnvObsv-CO2:", co2, "Temp", temp, "Humidity:", rh)) except Exception as e: status = 'Failure' if self._test: status = 'Test' c_rec = [ 'Environment_Observation', '', 'Top', 'Air', 'CO2', '', 'ppm', 'scd30', status, str(e) ] t_rec = [ 'Environment_Observation', '', 'Top', 'Air', 'Temperature', '', 'Centigrde', 'scd30', status, '' ] h_rec = [ 'Environment_Observation', '', 'Top', 'Air', 'Humidity', '', 'Percent', 'scd30', status, '' ] self._persist.save(c_rec) self._persist.save(t_rec) self._persist.save(h_rec) self._logger.debug("{} {}".format("EnvObsv-SCD30 Error:", e)) def log(self): '''Log extra sensors Uncomment desired sensors Imports are in the function to avoid loading unnecessary code ''' #self.getOneWire() self.getLux() self.getEC() self.getCO2_NDIR() #self.getCO2_CCS811() self.getSCD()
import asyncio from threading import Timer from datetime import datetime from Persistence import Persistence news_and_anouncements = "https://community.blackdesertonline.com/index.php?forums/news-announcements.181/index.rss" updates = "https://community.blackdesertonline.com/index.php?forums/patch-notes.5/index.rss" refreshTimer = None news_channel = None update_channel = None persistence = Persistence() loop = asyncio.get_event_loop() def check_for_updates(): newsParser = feedparser.parse(news_and_anouncements) updateParser = feedparser.parse(updates) print("update refresh\n") global refreshTimer refreshTimer = Timer(3600, check_for_updates) refreshTimer.start() new_news = list() new_updates = list()
minR = 0.1e-9 maxR = 50e-9 fileBase = './' outDir = './' outFile = open(outDir + 'deformation.dat','w') forceFile = open(outDir + 'force.dat', 'w') restartFileName = outDir + 'restart.hdf5' restartFileName = '' saveFileName = outDir + 'checkpoint.hdf5' if restartFileName != '': print 'I am restarting......' restartFile = Persistence(restartFileName,'r') else: restartFile = None solidCaseFile = fileBase + 'Gen5_beam_2D.cas' fluidCaseFile = fileBase + 'fluid_electrode_dielectric.cas' fluidReader = FluentCase(sys.argv[1]) solidReader = FluentCase(sys.argv[2]) fluidReader.read() solidReader.read() fluidMeshes = fluidReader.getMeshList() fluidMeshesOrig = fluidMeshes solidMeshes = solidReader.getMeshList()