예제 #1
0
    def setUp(self):
        super().setUp()
        # create another activitygroup
        ag_f = ActivityGroupFactory(keyflow=self.keyflow,
                                    name='Construction',
                                    code='F')
        ActivityGroupFactory(keyflow=self.keyflow,
                             name='Some stuff, no idea',
                             code='G')
        ActivityGroupFactory(keyflow=self.keyflow, name='Other', code='E')
        ActivityGroupFactory(keyflow=self.keyflow, name='Export', code='WE')
        ActivityGroupFactory(keyflow=self.keyflow, name='Import', code='R')

        af = ActivityFactory(activitygroup=ag_f,
                             name='should_be_updated',
                             nace='4110')
        ActivityFactory(activitygroup=ag_f,
                        name='Collection of non-hazardous waste',
                        nace='E-3811')
        ActivityFactory(activitygroup=ag_f,
                        name='Collection of hazardous waste',
                        nace='E-3812')
        ActivityFactory(activitygroup=ag_f,
                        name='shouldnt_be_updated',
                        nace='F-007')

        ActorFactory(activity=af, BvDid='NL000000029386')
        ActorFactory(activity=af, BvDid='NL32063450')
        ActorFactory(activity=af, BvDid='NL123')
예제 #2
0
    def setUp(self):
        super().setUp()
        # create another activitygroup
        ag = ActivityGroupFactory(keyflow=self.keyflow, name='A', code='A')
        af = ActivityFactory(activitygroup=ag, name='B', nace='123')

        ac_1 = ActorFactory(activity=af, BvDid='WK036306')
        ac_2 = ActorFactory(activity=af, BvDid='WK036307')
        ActorFactory(activity=af, BvDid='WK036308')
        ActorFactory(activity=af, BvDid='WK036309')
        ac_3 = ActorFactory(activity=af, BvDid='NL59307803')

        self.composition = CompositionFactory(name='RES @Urbanisation lvl 1')
        mat1 = MaterialFactory()
        mat2 = MaterialFactory()
        ProductFractionFactory(composition=self.composition,
                               material=mat1,
                               publication=None)
        ProductFractionFactory(composition=self.composition,
                               material=mat2,
                               publication=None)

        a = PublicationFactory(citekey='cbs2018', title='sth')
        PublicationInCasestudyFactory(casestudy=self.casestudy, publication=a)

        Actor2ActorFactory(origin=ac_1, destination=ac_2, keyflow=self.keyflow)
        Actor2ActorFactory(origin=ac_1, destination=ac_3, keyflow=self.keyflow)
예제 #3
0
 def create_actors(self):
     """Create the actors"""
     actor_names = {
         'oil_rig_den_haag': 'oil_rig',
         'oil_rig_rotterdam': 'oil_rig',
         'oil_refinery_rotterdam': 'oil_refinery',
         'shell_groningen_stock': 'stock',
         'production_utrecht': 'production',
         'production_leiden': 'production',
         'recycling_wageningen': 'recycling',
         'recycling_wageningen_stock': 'stock',
         'ah_den_haag_1': 'consumption',
         'ah_den_haag_2': 'consumption',
         'ah_den_haag_3': 'consumption',
         'packaging_leiden': 'packaging',
         'packaging_utrecht': 'packaging',
         'cucumber_farm_naaldwijk_1': 'farming',
         'cucumber_farm_naaldwijk_2': 'farming',
         'milk_farm_friesland_1': 'farming',
         'milk_farm_friesland_2': 'farming',
         'incinerator_eindhoven': 'waste_treatment',
         'paper_waste_collector_enschede': 'waste_treatment',
         'organic_waste_collector_nijmegen': 'waste_treatment'
     }
     self.actors = {}
     for actor_name, activity_name in actor_names.items():
         self.actors[actor_name] = ActorFactory(
             name=actor_name,
             activity__name=activity_name,
             activity__activitygroup__keyflow=self.kic)
예제 #4
0
    def test_actor_website(self):
        """Test updating a website for an actor"""
        # create actor and casestudy
        actor = ActorFactory()
        keyflow = actor.activity.activitygroup.keyflow

        # define the urls
        url_actor = reverse('actor-detail',
                            kwargs={
                                'casestudy_pk': keyflow.casestudy_id,
                                'keyflow_pk': keyflow.pk,
                                'pk': actor.pk,
                            })

        data_to_test = [
            {
                'website': 'website.without.http.de'
            },
            {
                'website': 'https://website.without.http.de'
            },
        ]

        for data in data_to_test:
            response = self.client.patch(url_actor, data)
            assert response.status_code == status.HTTP_200_OK

        data = {'website': 'website.without.http+.de'}
        response = self.client.patch(url_actor, data)
        assert response.status_code == status.HTTP_400_BAD_REQUEST
예제 #5
0
 def setUp(self):
     super().setUp()
     self.kic_obj = KeyflowInCasestudyFactory(id=self.keyflowincasestudy,
                                              casestudy=self.uic.casestudy,
                                              keyflow__id=self.keyflow)
     self.mat_obj_1 = MaterialFactory(id=self.material_1,
                                      keyflow=self.kic_obj)
     self.mat_obj_2 = MaterialFactory(id=self.material_2,
                                      keyflow=self.kic_obj)
     self.comp1 = CompositionFactory(name='composition1', nace='nace1')
     self.comp2 = CompositionFactory(name='composition2', nace='nace2')
     self.activitygroup1 = ActivityGroupFactory(keyflow=self.kic_obj)
     self.activity1 = ActivityFactory(activitygroup=self.activitygroup1)
     self.actor1 = ActorFactory(id=self.actor1id, activity=self.activity1)
     self.activitygroup2 = ActivityGroupFactory(keyflow=self.kic_obj)
     self.activity2 = ActivityFactory(activitygroup=self.activitygroup2)
     self.actor2 = ActorFactory(id=self.actor2id, activity=self.activity2)
     self.actor3 = ActorFactory(activity=self.activity2)
     self.act2act1 = Actor2ActorFactory(
         id=self.actor2actor1,
         origin=self.actor1,
         destination=self.actor2,
         keyflow=self.kic_obj,
         composition=self.comp1,
     )
     self.act2act2 = Actor2ActorFactory(
         id=self.actor2actor2,
         origin=self.actor2,
         destination=self.actor3,
         keyflow=self.kic_obj,
         composition=self.comp2,
     )
     self.actorstock1 = ActorStockFactory(id=self.actorstock,
                                          keyflow=self.kic_obj,
                                          origin=self.actor1)
     self.actorstock2 = ActorStockFactory(id=self.actorstock2,
                                          keyflow=self.kic_obj,
                                          origin=self.actor2)
     self.obj = self.actorstock1
예제 #6
0
 def test_actor_included(self):
     """Test a geolocation"""
     actor1 = ActorFactory(included=True)
     actor2 = ActorFactory(included=True)
     actor1.included = False
     actor1.save()
     excluded_actors = Actor.objects.filter(included=False)
     # test that there is now at least one ignored actor
     assert excluded_actors.count() > 0
     assert excluded_actors.first().included is False
예제 #7
0
    def setUpClass(cls):
        super().setUpClass()
        # Create a solution with 3 parts 2 questions
        cls.solution = SolutionFactory()

        question_1 = ImplementationQuestionFactory(
            question="What is the answer to life, the universe and everything?",
            select_values='0.0,3.14,42,1234.4321',
            solution=cls.solution)
        question_2 = ImplementationQuestionFactory(question="What is 1 + 1?",
                                                   min_value=1,
                                                   max_value=1000,
                                                   step=1,
                                                   solution=cls.solution)

        possible_implementation_area_1 = PossibleImplementationAreaFactory(
            solution=cls.solution,
            geom=MultiPolygon(
                Polygon(((0.0, 0.0), (0.0, 20.0), (56.0, 20.0), (56.0, 0.0),
                         (0.0, 0.0)))),
            question=(""))

        possible_implementation_area_2 = PossibleImplementationAreaFactory(
            solution=cls.solution,
            geom=MultiPolygon(
                Polygon(((0.0, 0.0), (0.0, 20.0), (56.0, 20.0), (56.0, 0.0),
                         (0.0, 0.0)))),
            question=(""))

        part_1 = SolutionPartFactory(solution=cls.solution,
                                     question=question_1,
                                     a=0,
                                     b=1)
        part_2 = SolutionPartFactory(solution=cls.solution,
                                     question=question_2)

        # new target with new actors
        target_activity = ActivityFactory(name='target_activity')
        for i in range(3):
            ActorFactory(activity=target_activity)

        new_target = FlowReferenceFactory(
            destination_activity=target_activity,
            destination_area=possible_implementation_area_1)

        part_new_flow = SolutionPartFactory(solution=cls.solution,
                                            question=question_1,
                                            flow_changes=new_target)
예제 #8
0
    def setUpClass(cls):
        super().setUpClass()
        cls.keyflow = KeyflowInCasestudyFactory(id=2)
        cls.pub = PublicationInCasestudyFactory(
            casestudy=cls.keyflow.casestudy)

        ## Materials ##

        bread = MaterialFactory(name='bread', keyflow=cls.keyflow)
        beer = MaterialFactory(name='beer', keyflow=cls.keyflow)
        barley = MaterialFactory(name='barley', keyflow=cls.keyflow)
        sludge = MaterialFactory(name='sludge', keyflow=cls.keyflow)
        other_waste = MaterialFactory(name='other waste', keyflow=cls.keyflow)

        ## Processes ##
        dummy_process = ProcessFactory(name='process')

        ## Activities and Activity groups ##

        group_A = ActivityGroupFactory(name='A', code='A', keyflow=cls.keyflow)
        group_C = ActivityGroupFactory(name='C', code='C', keyflow=cls.keyflow)

        brewing_activity = ActivityFactory(name='Brewery',
                                           nace='A-0000',
                                           activitygroup=group_A)
        household_activity = ActivityFactory(name='Household',
                                             nace='A-0001',
                                             activitygroup=group_A)
        digester_activity = ActivityFactory(name='Digester',
                                            nace='A-0002',
                                            activitygroup=group_A)
        supermarket_activity = ActivityFactory(name='Supermarket',
                                               nace='A-0003',
                                               activitygroup=group_A)
        farming_activity = ActivityFactory(name='Farming',
                                           nace='C-0000',
                                           activitygroup=group_C)
        inciterator_activity = ActivityFactory(name='Incineration',
                                               nace='C-0001',
                                               activitygroup=group_C)

        ## Actors ##

        # random households
        for i in range(100):
            ActorFactory(name='household{}'.format(i),
                         activity=household_activity)
        # random supermarkets
        for i in range(10):
            ActorFactory(name='supermarket{}'.format(i),
                         activity=supermarket_activity)
        # random farms
        for i in range(2):
            ActorFactory(name='farm{}'.format(i), activity=farming_activity)

        cls.brewery_1 = ActorFactory(name='brewery_1',
                                     activity=brewing_activity)
        cls.brewery_2 = ActorFactory(name='brewery_2',
                                     activity=brewing_activity)
        digester = ActorFactory(name='digester Amsterdam',
                                activity=digester_activity)
        incinerator = ActorFactory(name='incinerator Amsterdam',
                                   activity=inciterator_activity)

        ## status quo flows ##
        households = Actor.objects.filter(activity=household_activity)
        farms = Actor.objects.filter(activity=farming_activity)
        breweries = Actor.objects.filter(activity=brewing_activity)
        supermarkets = Actor.objects.filter(activity=supermarket_activity)

        input_digester = 1000 / len(households)
        input_incinerator_bread = 500 / len(households)
        input_incinerator_other = 1500 / len(households)
        input_brewery_barley = 900 / len(farms)
        input_supermarket_beer = 4000 / (len(supermarkets) * len(breweries))

        # B: or whats with the FractionFlows?
        for i, household in enumerate(households):
            FractionFlowFactory(origin=household,
                                destination=digester,
                                material=bread,
                                amount=input_digester,
                                keyflow=cls.keyflow)
        for i, household in enumerate(households):
            FractionFlowFactory(origin=household,
                                destination=incinerator,
                                material=bread,
                                amount=input_incinerator_bread,
                                keyflow=cls.keyflow)
            FractionFlowFactory(origin=household,
                                destination=incinerator,
                                material=other_waste,
                                amount=input_incinerator_other,
                                keyflow=cls.keyflow)
        for i, farm in enumerate(farms):
            brewery = breweries[i]
            FractionFlowFactory(origin=farm,
                                destination=brewery,
                                material=barley,
                                amount=input_brewery_barley,
                                keyflow=cls.keyflow)
        for supermarket in supermarkets:
            for brewery in breweries:
                FractionFlowFactory(origin=brewery,
                                    destination=supermarket,
                                    material=beer,
                                    amount=input_supermarket_beer,
                                    keyflow=cls.keyflow)
        for brewery in breweries:
            FractionFlowFactory(origin=brewery,
                                destination=digester,
                                material=sludge,
                                amount=1000,
                                keyflow=cls.keyflow)
예제 #9
0
 def setUp(self):
     super().setUp()
     self.reason1 = ReasonFactory(id=self.reason1_id, reason='Reason 1')
     self.reason2 = ReasonFactory(id=self.reason2_id, reason='Reason 2')
     self.obj = ActorFactory(activity__activitygroup__keyflow=self.kic,
                             reason=self.reason1)
예제 #10
0
    def setUp(self):
        super().setUp()
        self.casestudy = CaseStudyFactory(name=self.csname)
        self.kic_obj = KeyflowInCasestudyFactory(id=self.keyflowincasestudy,
                                                 casestudy=self.casestudy,
                                                 keyflow__id=self.keyflow_id)
        self.activitygroup1 = ActivityGroupFactory(keyflow=self.kic_obj)
        self.activity1 = ActivityFactory(activitygroup=self.activitygroup1)
        self.actor1 = ActorFactory(id=self.actor1id, activity=self.activity1)
        self.activitygroup2 = ActivityGroupFactory(keyflow=self.kic_obj)
        self.activity2 = ActivityFactory(activitygroup=self.activitygroup2)
        self.actor2 = ActorFactory(id=self.actor2id, activity=self.activity2)
        self.activitygroup3 = ActivityGroupFactory(keyflow=self.kic_obj)
        self.activity3 = ActivityFactory(activitygroup=self.activitygroup3)
        self.actor3 = ActorFactory(id=self.actor3id, activity=self.activity3)

        self.comp1 = CompositionFactory(name='composition1', nace='nace1')
        self.comp2 = CompositionFactory(name='composition2', nace='nace2')
        self.mat_obj_1 = MaterialFactory(id=self.material_1,
                                         keyflow=self.kic_obj,
                                         parent=None)
        self.mat_obj_2 = MaterialFactory(id=self.material_2,
                                         keyflow=self.kic_obj,
                                         parent=self.mat_obj_1)
        self.publicationic = PublicationInCasestudyFactory()

        # flow attributes
        #self.process = ProcessFactory(name='test-process')

        self.fractionflow1 = FractionFlowFactory(
            flow_id=self.flowid1,
            #process=self.process,
            stock=None,
            to_stock=False,
            origin=self.actor1,
            destination=self.actor2,
            material=self.mat_obj_1,
            nace=self.comp1.nace,
            composition_name=self.comp1.name,
            publication=self.publicationic,
            keyflow=self.kic_obj,
            amount=1.0)
        self.fractionflow2 = FractionFlowFactory(
            flow_id=self.flowid2,
            stock=None,
            to_stock=False,
            origin=self.actor2,
            destination=self.actor3,
            material=self.mat_obj_2,
            nace=self.comp1.nace,
            composition_name=self.comp1.name,
            publication=self.publicationic,
            keyflow=self.kic_obj,
            amount=1.0)
        self.fractionflow3 = FractionFlowFactory(
            flow_id=self.flowid3,
            stock=None,
            to_stock=False,
            origin=self.actor2,
            destination=self.actor3,
            material=self.mat_obj_1,
            nace=self.comp2.nace,
            composition_name=self.comp2.name,
            publication=self.publicationic,
            keyflow=self.kic_obj,
            amount=1.0)
 def setUp(self):
     super().setUp()
     self.area1 = AreaFactory(id=self.area_id1, )
     self.area2 = AreaFactory(id=self.area_id2, )
     self.actor1 = ActorFactory(id=self.actor_id1)
     self.actor2 = ActorFactory(id=self.actor_id2)
     self.actor3 = ActorFactory(id=self.actor_id3)
     self.actor4 = ActorFactory(id=self.actor_id4)
     self.actor5 = ActorFactory(id=self.actor_id5)
     self.composition1 = CompositionFactory()
     self.flow1 = Actor2ActorFactory(id=self.flow_id1,
                                     keyflow=self.kic,
                                     composition=self.composition1,
                                     origin=self.actor1,
                                     destination=self.actor2)
     self.flow2 = Actor2ActorFactory(id=self.flow_id2,
                                     keyflow=self.kic,
                                     composition=self.composition1,
                                     origin=self.actor2,
                                     destination=self.actor3)
     self.flow3 = Actor2ActorFactory(id=self.flow_id3,
                                     keyflow=self.kic,
                                     composition=self.composition1,
                                     origin=self.actor3,
                                     destination=self.actor5)
     self.flow4 = Actor2ActorFactory(id=self.flow_id4,
                                     keyflow=self.kic,
                                     composition=self.composition1,
                                     origin=self.actor5,
                                     destination=self.actor4)
     self.flow5 = Actor2ActorFactory(id=self.flow_id5,
                                     keyflow=self.kic,
                                     composition=self.composition1,
                                     origin=self.actor5,
                                     destination=self.actor3)
     self.flow6 = Actor2ActorFactory(id=self.flow_id6,
                                     keyflow=self.kic,
                                     composition=self.composition1,
                                     origin=self.actor1,
                                     destination=self.actor3)
     self.material1 = MaterialFactory(keyflow=self.kic)
     self.flow_a = IndicatorFlowFactory(origin_node_ids='1, 2, 3',
                                        destination_node_ids='4, 5',
                                        materials=[self.material1])
     self.flow_b = IndicatorFlowFactory(origin_node_ids='1, 2',
                                        destination_node_ids='3, 4, 5',
                                        materials=[self.material1])
     self.obj = FlowIndicatorFactory(flow_a=self.flow_a,
                                     flow_b=self.flow_b,
                                     keyflow=self.kic)
     self.post_data = dict(
         name='FlowIndicator',
         unit='Elmshorn',
         description='supernormal',
         indicator_type='A',
         flow_a=[self.flow_a],
         flow_b=[self.flow_b],
         keyflow=self.keyflow_id1,
     )
     self.put_data = self.post_data
     self.patch_data = self.post_data
예제 #12
0
    def setUpClass(cls):
        super().setUpClass()

        ### Modeling the FUNGUS solution and the status quo it is based on ###

        cls.keyflow = KeyflowInCasestudyFactory()

        ##  Materials ##

        dummy_mat_1 = MaterialFactory(keyflow=cls.keyflow)
        dummy_mat_2 = MaterialFactory(keyflow=cls.keyflow)
        wool = MaterialFactory(name='wool insulation', keyflow=cls.keyflow)
        fungus = MaterialFactory(name='fungus insulation', keyflow=cls.keyflow)
        # no idea about the processes, but the process of wool-insulation flow
        # to E-3821 is supposed to be different to the fungus-insulation one
        dummy_process = ProcessFactory(name='process')
        compost = ProcessFactory(name='compost')

        ## Activities and Activity groups ##

        group_A = ActivityGroupFactory(name='A', code='A', keyflow=cls.keyflow)
        group_C = ActivityGroupFactory(name='C', code='C', keyflow=cls.keyflow)
        group_E = ActivityGroupFactory(name='E', code='E', keyflow=cls.keyflow)
        group_F = ActivityGroupFactory(name='F', code='F', keyflow=cls.keyflow)
        group_V = ActivityGroupFactory(name='V', code='V', keyflow=cls.keyflow)
        dummy_group = ActivityGroupFactory(keyflow=cls.keyflow)

        growing_activity = ActivityFactory(
            name='A-0116 Growing of fibre crops',
            nace='A-0116',
            activitygroup=group_A)
        manufacture_activity = ActivityFactory(
            name='C-2399 Manufacture of non-metallic mineral products',
            nace='C-2399',
            activitygroup=group_C)
        collection_activity = ActivityFactory(
            name='E-3819 Collection of non-hazardous waste',
            nace='E-3819',
            activitygroup=group_E)
        treatment_activity = ActivityFactory(
            name='E-3821 Treatment and disposal of non-hazardous waste',
            nace='E-3821',
            activitygroup=group_E)
        building_activity = ActivityFactory(
            name='F-4110 Development of building projects',
            nace='F-4110',
            activitygroup=group_E)
        consumption_activity = ActivityFactory(
            name='V-0000 Consumption in households',
            nace='V-0000',
            activitygroup=group_V)
        dummy_activity_1 = ActivityFactory(activitygroup=dummy_group)
        dummy_activity_2 = ActivityFactory(activitygroup=dummy_group)

        ## Actors ##

        # random households
        for i in range(100):
            ActorFactory(name='household{}'.format(i),
                         activity=consumption_activity)

        for i in range(2):
            building_dev = ActorFactory(name='buildingdev{}'.format(i),
                                        activity=building_activity)
            # this activity is set as spatial choice in the following solution
            # parts -> they have to be geolocated (just putting it somewhere)
            # Note CF: geolocate the other models as well?
            location = AdministrativeLocationFactory(actor=building_dev,
                                                     geom=Point(x=5, y=52))

        collection_insulation = ActorFactory(name='collection',
                                             activity=collection_activity)

        manufacturer = ActorFactory(name='manufacturer'.format(i),
                                    activity=manufacture_activity)

        # put some dummy actors into the dummy activities
        for i in range(10):
            ActorFactory(activity=dummy_activity_1)
            ActorFactory(activity=dummy_activity_2)

        treatment_insulation = ActorFactory(name='disposal',
                                            activity=treatment_activity)
        cls.treatment_compost = ActorFactory(name='compost',
                                             activity=treatment_activity)

        # putting the fungus farms into "growing fibre crops" lacking better
        # knowledge
        fungus_input = ActorFactory(name='chungus', activity=growing_activity)
        cls.fungus_farm_1 = ActorFactory(name='fungus1',
                                         activity=growing_activity)
        cls.fungus_farm_2 = ActorFactory(name='fungus2',
                                         activity=growing_activity)

        ## status quo flows and stocks ##

        # making stuff up going into the fungus farm
        FractionFlowFactory(origin=fungus_input,
                            destination=cls.fungus_farm_1,
                            material=dummy_mat_1,
                            amount=20)
        FractionFlowFactory(origin=fungus_input,
                            destination=cls.fungus_farm_2,
                            material=dummy_mat_2,
                            amount=10)

        # fungus stock to possibly derive from
        # (Note CF: is there a stock? better: put the output to the treatment)
        FractionFlowFactory(origin=cls.fungus_farm_1,
                            material=fungus,
                            amount=10)
        FractionFlowFactory(origin=cls.fungus_farm_2,
                            material=fungus,
                            amount=10)
        # (Note CF: set stocks as affected flows?)

        households = Actor.objects.filter(activity=consumption_activity)
        # every household gets same share of 200,000 t/y activity stock
        stock_share = 200000 / len(households)
        # Note CF: no idea how much should go in per year
        input_share = 10 / len(households)
        builders = Actor.objects.filter(activity=building_activity)
        step = len(households) / len(builders)

        # household stock and input
        for i, household in enumerate(households):
            # stock
            FractionFlowFactory(origin=household,
                                material=wool,
                                amount=stock_share)
            # equally distribute the inputs from the building developers
            builder = builders[int(i / step)]
            FractionFlowFactory(origin=builder,
                                destination=household,
                                material=wool,
                                amount=input_share)

        input_share = 5 / len(builders)  # Note CF: how much goes in?
        # inputs and outputs of builders
        for builder in builders:
            # from manufacturer
            FractionFlowFactory(origin=manufacturer,
                                destination=builder,
                                material=wool,
                                amount=input_share)
            # to collection
            FractionFlowFactory(origin=builder,
                                destination=collection_insulation,
                                material=wool,
                                amount=1)
            # to treatment
            FractionFlowFactory(origin=builder,
                                destination=treatment_insulation,
                                material=wool,
                                amount=3)

        # collection to treatment
        FractionFlowFactory(origin=collection_insulation,
                            destination=treatment_insulation,
                            material=wool,
                            amount=2)

        # manufacturer to treatment
        FractionFlowFactory(origin=manufacturer,
                            destination=treatment_insulation,
                            material=wool,
                            amount=2)

        ## solution definition ##

        cls.solution = SolutionFactory(name='Fungus Isolation')

        cls.fungus_question = ImplementationQuestionFactory(
            question=("How many tonnes per year of fungus should be used as "
                      "insulation material when developing new "
                      "living quarters?"),
            solution=cls.solution,
            min_value=0,
            is_absolute=True  # Note CF: is it?
        )

        cls.possible_implementation_area = PossibleImplementationAreaFactory(
            solution=cls.solution,
            geom=MultiPolygon(
                Polygon(((0.0, 0.0), (0.0, 20.0), (56.0, 20.0), (56.0, 0.0),
                         (0.0, 0.0)))),
            question=("Where are the facilities for composting "
                      "the fungus located?"))

        ## solution parts ##

        # the new flow based on flows from c-2399 to f-4110
        # Note CF: optional it could also be derived from flows out of the farms

        implementation = FlowReferenceFactory(
            origin_activity=manufacture_activity,
            destination_activity=building_activity,
            material=wool)

        shift = FlowReferenceFactory(origin_activity=growing_activity,
                                     material=fungus)

        cls.new_fungus_insulation = SolutionPartFactory(
            solution=cls.solution,
            question=cls.fungus_question,
            flow_reference=implementation,
            flow_changes=shift,
            scheme=Scheme.SHIFTORIGIN,
            a=1,
            b=0,
            priority=1)

        # the new flow based on flows from c-2399 to f-4110
        # Note CF: optional it could also be derived from flows out of the farms

        implementation = FlowReferenceFactory(
            origin_activity=consumption_activity,
            destination_activity=None,
            process=dummy_process,
            material=wool)

        # origin actually stays the same but there is no way to shift without
        # referring to either new destination or origin
        shift = FlowReferenceFactory(origin_activity=consumption_activity,
                                     material=fungus)

        new_fungus_stock = SolutionPartFactory(solution=cls.solution,
                                               question=cls.fungus_question,
                                               flow_reference=implementation,
                                               flow_changes=shift,
                                               scheme=Scheme.SHIFTORIGIN,
                                               a=1,
                                               b=0,
                                               priority=2)

        # new flow from F-4110 development to E-3821 treatment
        # Note CF: deriving it from existing F4110 to E3821, just guessing

        implementation = FlowReferenceFactory(
            origin_activity=building_activity,
            destination_activity=treatment_activity,
            material=wool,
            process=dummy_process)

        # actually both activities stay the same
        shift = FlowReferenceFactory(
            origin_activity=building_activity,
            destination_activity=treatment_activity,
            material=fungus,
            process=compost,
            destination_area=cls.possible_implementation_area)

        cls.new_building_disposal = SolutionPartFactory(
            solution=cls.solution,
            # Note CF: i guess we need different numbers than asked for in this
            # question, or do we even need a question??
            question=cls.fungus_question,
            flow_reference=implementation,
            flow_changes=shift,
            scheme=Scheme.SHIFTDESTINATION,
            a=1,
            b=0,
            priority=3)

        # new flow from fungus farms to E-3821 treatment
        # Note CF: most likely this should already be modelled in the status quo
        # deriving it from fungus stock

        implementation = FlowReferenceFactory(origin_activity=growing_activity,
                                              destination_activity=None,
                                              process=compost,
                                              material=fungus)

        # origin actually stays the same but there is no way to shift without
        # referring to either new destination or origin
        shift = FlowReferenceFactory(
            destination_activity=treatment_activity,
            destination_area=cls.possible_implementation_area,
            material=fungus)

        # Note CF: reduce existing implementation flow?

        new_fungus_disposal = SolutionPartFactory(
            solution=cls.solution,
            # Note CF: is there a question???
            question=None,
            flow_reference=implementation,
            flow_changes=shift,
            scheme=Scheme.SHIFTDESTINATION,
            a=1,
            b=0,
            priority=4)

        ## affected flows ##

        # Note CF: poor pull leader has to define the affected flows for
        # every part, just taking the same ones for all parts
        # (marking the implementation flows as well, i guess that doesn't matter)
        # B: who cares about the pull leader?!

        parts = [
            cls.new_fungus_insulation, new_fungus_stock,
            cls.new_building_disposal, new_fungus_disposal
        ]

        for part in parts:
            # F-4110 to V-0000
            AffectedFlow(origin_activity=building_activity,
                         destination_activity=consumption_activity,
                         material=wool,
                         solution_part=part)

            # Note CF: insulation stock of V-0000 affected as well?

            # inputs of fungus farm, origin and destination are in same activity
            # Note CF: might not be this way in reality, maybe inputs come from
            # different activity? stock missing
            AffectedFlow(origin_activity=growing_activity,
                         destination_activity=growing_activity,
                         material=dummy_mat_1,
                         solution_part=part)
            AffectedFlow(origin_activity=growing_activity,
                         destination_activity=growing_activity,
                         material=dummy_mat_2,
                         solution_part=part)

            # F-4110 to E-3821
            AffectedFlow(origin_activity=building_activity,
                         destination_activity=treatment_activity,
                         material=wool,
                         solution_part=part)
            # F-4110 to E-3819
            AffectedFlow(origin_activity=building_activity,
                         destination_activity=collection_activity,
                         material=wool,
                         solution_part=part)

            # C-2399 to F-4110
            AffectedFlow(origin_activity=manufacture_activity,
                         destination_activity=building_activity,
                         material=wool,
                         solution_part=part)

            # E-3819 to E-3821
            AffectedFlow(origin_activity=collection_activity,
                         destination_activity=treatment_activity,
                         material=wool,
                         solution_part=part)