Пример #1
0
def lca():

	session_name = 'Indiana-IUC'
	mynetwork = IndianaNetwork(file_name = "INDIANA2019",
								n_assets = -1,
								settings = settings,
								is_deck = True,
				                is_superstructure = True,
				                is_substructure = True)
	mynetwork.load_network()

	mynetwork.set_current_budget_limit(10000)
	mynetwork.set_budget_limit_model(Linear(X0 = 10000, drift = 0, settings = settings))
	mynetwork.set_npv_budget_limit(100000)

	simulator = MainSimulator(settings = settings)
	lca = LCA(lca_name = session_name,
			settings = settings,
			network = mynetwork,
			simulator = simulator,
			random = False,
			is_hazard = False,
			n_simulations = 5,
			should_report = True)

	return lca
Пример #2
0
def lca_instance():

    # Creating the settings instance
    settings = GeneralSettings()

    # Creating the network
    session_name = 'IndianaSHM'
    mynetwork = DummySHMNetwork(file_name="INDIANA2019",
                                settings=settings,
                                n_assets=1,
                                is_deck=False,
                                is_superstructure=True,
                                is_substructure=False)
    mynetwork.load_network()
    mynetwork.set_current_budget_limit(100000)
    mynetwork.set_budget_limit_model(
        Linear(X0=100000, drift=0, settings=settings))
    mynetwork.set_npv_budget_limit(10000)

    # Creating the simulator
    simulator = MainSimulator(settings=settings)

    # shaping the main LCA
    lca = LCA(lca_name=session_name,
              settings=settings,
              network=mynetwork,
              simulator=simulator,
              random=True,
              is_hazard=True,
              n_simulations=10,
              should_report=True)

    return lca
Пример #3
0
def lca_for_validation(mrrs, q_out):

    for mrr in mrrs:

        session_name = 'Indiana'
        mynetwork = IndianaNetwork("INDIANA2019",
                                   n_assets=1,
                                   is_deck=False,
                                   is_superstructure=True,
                                   is_substructure=False)
        mynetwork.load_network()
        mynetwork.set_current_budget_limit(100000)
        mynetwork.set_budget_limit_model(Linear(X0=100000, drift=0))
        mynetwork.set_npv_budget_limit(10000)

        mynetwork.assets[0].mrr_model.set_mrr(np.atleast_2d(mrr))

        simulator = MainSimulator()
        lca = LCA(network=mynetwork,
                  lca_name=session_name,
                  simulator=simulator,
                  random=False,
                  is_hazard=False,
                  n_simulations=1000)

        lca.run()
        results = lca.get_network_npv()

        q_out.put(mrr + results)
Пример #4
0
def lca(mrr=None):

    session_name = 'Indiana'

    mynetwork = IndianaNetwork("INDIANA2019",
                               n_assets=1,
                               is_deck=False,
                               is_superstructure=True,
                               is_substructure=False)
    mynetwork.load_network()

    if not mrr is None:
        mynetwork.assets[0].mrr_model.set_mrr(mrr)

    mynetwork.set_current_budget_limit(100000)
    mynetwork.set_budget_limit_model(Linear(X0=100000, drift=0))
    mynetwork.set_npv_budget_limit(10000)

    simulator = MainSimulator()
    lca = LCA(network=mynetwork,
              lca_name=session_name,
              simulator=simulator,
              random=False,
              is_hazard=False,
              n_simulations=500)

    return lca
Пример #5
0
class DummyUserCost(BaseUserCost):
    def __init__(self, **params):
        super().__init__(**params)
        self.linear_model = Linear(X0=1, drift=0, settings=self.settings)

    def predict_series(self, project_duration, random=True):
        '''Method for predicting the user costs in time'''
        return 3 * self.linear_model.predict_series(random)
        # The out put will be 1000 dollars
Пример #6
0
class RetrofitCosts(BaseAgencyCost):
    def __init__(self):
        self.linear_model = Linear(X0=1, drift=0, settings=self.settings)
        pass

    def retrofit_costs(self, random):
        check_random(random)
        return 100 * self.linear_model.predict_series(random) / 1000

    def predict_series(self, random):
        return {BINAR: self.retrofit_costs(random)}
Пример #7
0
class RetrofitCosts(BaseAgencyCost):
    def __init__(self):
        self.linear_model = Linear(X0=1, drift=0, settings=self.settings)
        pass

    def first_inspection_cost(self, random):
        return 1 * self.linear_model.predict_series(random) / 1000

    def further_inspection_cost(self, random):
        return 10 * self.linear_model.predict_series(random) / 1000

    def action_costs(self, random):
        return 100 * self.linear_model.predict_series(random) / 1000

    def predict_series(self, random):
        assert isinstance(random, bool), 'random must be boolean'
        return {
            INSP1: self.first_inspection_costs(random),
            INSP2: self.further_inspection_costs(random),
            DOMNT: self.action_costs(random)
        }
Пример #8
0
def lca():

	session_name = 'BuildingRetrofit'
	
	mynetwork = BuildingNetwork(None, n_assets = 5)
	mynetwork.load_network()

	mynetwork.set_current_budget_limit(100000)
	mynetwork.set_budget_limit_model(Linear(X0 = 100000, drift = 0))
	mynetwork.set_npv_budget_limit(10000)

	simulator = DummyRiskAnalyzer()
	lca = LCA(network = mynetwork,
			lca_name = session_name,
			simulator = simulator,
			random = False,
			is_hazard = False,
			n_simulations = 1)

	return lca
Пример #9
0
def lca_instance():

	# Creating the settings instance
	settings = GeneralSettings()

	# Creating the network
	session_name = 'IndianaTest'
	mynetwork = IndianaNetwork(file_name = "INDIANA2019",
								settings = settings,
								n_assets = 1,
								is_deck = True,
				                is_superstructure = True,
				                is_substructure = True)
	mynetwork.load_network()

	new_mrr = np.array([[1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1],
						[0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1],
						[1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1]])


	mynetwork.assets[0].mrr_model.set_mrr(new_mrr)
	mynetwork.set_current_budget_limit(100000)
	mynetwork.set_budget_limit_model(Linear(X0 = 100000, drift = 0, settings = settings))
	mynetwork.set_npv_budget_limit(10000)

	# Creating the simulator
	simulator = MainSimulator(settings = settings)

	# shaping the main LCA
	lca = LCA(lca_name = session_name,
			settings = settings,
			network = mynetwork,
			simulator = simulator,
			random = True,
			is_hazard = True,
			n_simulations = 20,
			should_report = True)

	return lca
Пример #10
0
 def __init__(self):
     self.linear_model = Linear(X0=1, drift=0, settings=self.settings)
     pass
Пример #11
0
 def __init__(self, **params):
     super().__init__(**params)
     self.linear_model = Linear(X0=1, drift=0, settings=self.settings)