def function(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')
        age_holder = simulation.compute('age', period)
        smic55_holder = simulation.compute('smic55', period)
        activite_holder = simulation.compute('activite', period)
        nb_par = simulation.calculate('nb_par', period)
        rmi = simulation.legislation_at(period.start).minim.rmi

        age_parents = self.split_by_roles(age_holder, roles = [CHEF, PART])
        activite_parents = self.split_by_roles(activite_holder, roles = [CHEF, PART])
        age_enf = self.split_by_roles(age_holder, roles = ENFS)
        smic55_enf = self.split_by_roles(smic55_holder, roles = ENFS)

        nbp = nb_par + nb_enf(age_enf, smic55_enf, 0, rmi.age_pac)

        eligib = (
            (age_parents[CHEF] >= rmi.age_pac)
            &
            not_(activite_parents[CHEF] == 2)
            ) | (
                (age_parents[PART] >= rmi.age_pac) & not_(activite_parents[PART] == 2)
                )

        taux = (
            1 + (nbp >= 2) * rmi.txp2 +
            (nbp >= 3) * rmi.txp3 +
            (nbp >= 4) * ((nb_par == 1) * rmi.txps + (nb_par != 1) * rmi.txp3) +
            max_(nbp - 4, 0) * rmi.txps
            )
        return period, eligib * rmi.rmi * taux

def _rsa_socle(self, age_holder, smic55_holder, activite_holder, nb_par, rmi = law.minim.rmi):
    '''
    Rsa socle / Rmi
    'fam'
    '''
    age_parents = self.split_by_roles(age_holder, roles = [CHEF, PART])
    activite_parents = self.split_by_roles(activite_holder, roles = [CHEF, PART])
    age_enf = self.split_by_roles(age_holder, roles = ENFS)
    smic55_enf = self.split_by_roles(smic55_holder, roles = ENFS)

    nbp = nb_par + nb_enf(age_enf, smic55_enf, 0, rmi.age_pac)

    eligib = (
        (age_parents[CHEF] >= rmi.age_pac)
        *
        not_(activite_parents[CHEF] == 2)
        ) | (
            (age_parents[PART] >= rmi.age_pac) * not_(activite_parents[PART] == 2)
            )

    taux = (1 + (nbp >= 2) * rmi.txp2
                 + (nbp >= 3) * rmi.txp3
                 + (nbp >= 4) * ((nb_par == 1) * rmi.txps + (nb_par != 1) * rmi.txp3)
                 + max_(nbp - 4, 0) * rmi.txps)

    return eligib * rmi.rmi * taux * 12

def _saldom2(nb_pac2, f7db, f7dg, f7dl, f7dq, _P):
    '''
    Crédit d’impôt emploi d’un salarié à domicile (cases 7DB, 7DG)
    2007-
    '''
    P = _P.ir.reductions_impots.saldom

    isinvalid = f7dg

    if _P.datesim.year in (2007, 2008):
        nbpacmin = nb_pac2 + f7dl
        maxBase = P.max1
        maxDuMaxNonInv = P.max2
        maxNonInv = min_(maxBase + P.pac * nbpacmin, maxDuMaxNonInv)
        maxEffectif = maxNonInv * not_(isinvalid) + P.max3 * isinvalid

    elif _P.datesim.year in (2009, 2010):
        annee1 = f7dq
        nbpacmin = nb_pac2 + f7dl
        maxBase = P.max1 * not_(annee1) + P.max1_1ereAnnee * annee1
        maxDuMaxNonInv = P.max2 * not_(annee1) + P.max2_1ereAnnee * annee1
        maxNonInv = min_(maxBase + P.pac * nbpacmin, maxDuMaxNonInv)
        maxEffectif = maxNonInv * not_(isinvalid) + P.max3 * isinvalid

    elif _P.datesim.year >= 2011:
        # TODO:
        maxEffectif = 0

    return P.taux * min_(f7db, maxEffectif)

    def function(famille, period, legislation):
        period = period.this_month
        al = legislation(period).prestations.aides_logement
        couple = famille('al_couple', period)
        al_nb_pac = famille('al_nb_personnes_a_charge', period)
        residence_dom = famille.demandeur.menage('residence_dom')

        TF_metropole = (
            al.taux_participation_fam.taux_1_adulte * (not_(couple)) * (al_nb_pac == 0) +
            al.taux_participation_fam.taux_2_adulte * (couple) * (al_nb_pac == 0) +
            al.taux_participation_fam.taux_1_enf * (al_nb_pac == 1) +
            al.taux_participation_fam.taux_2_enf * (al_nb_pac == 2) +
            al.taux_participation_fam.taux_3_enf * (al_nb_pac == 3) +
            al.taux_participation_fam.taux_4_enf * (al_nb_pac >= 4) +
            al.taux_participation_fam.taux_enf_supp * (al_nb_pac > 4) * (al_nb_pac - 4)
            )

        TF_dom = (
            al.taux_participation_fam.dom.taux1 * (not_(couple)) * (al_nb_pac == 0) +
            al.taux_participation_fam.dom.taux2 * (couple) * (al_nb_pac == 0) +
            al.taux_participation_fam.dom.taux3 * (al_nb_pac == 1) +
            al.taux_participation_fam.dom.taux4 * (al_nb_pac == 2) +
            al.taux_participation_fam.dom.taux5 * (al_nb_pac == 3) +
            al.taux_participation_fam.dom.taux6 * (al_nb_pac == 4) +
            al.taux_participation_fam.dom.taux7 * (al_nb_pac == 5) +
            al.taux_participation_fam.dom.taux8 * (al_nb_pac >= 6)
            )

        return period, where(residence_dom, TF_dom, TF_metropole)

    def function(self, simulation, period):
        '''
        type de menage
        'men'
        TODO: prendre les enfants du ménage et non ceux de la famille
        '''
        period = period.this_year
        en_couple_holder = simulation.compute('en_couple', period)
        af_nbenf_holder = simulation.compute('af_nbenf', period)

        af_nbenf = self.cast_from_entity_to_role(af_nbenf_holder, role = CHEF)
        af_nbenf = self.sum_by_entity(af_nbenf)
        isole = not_(self.cast_from_entity_to_role(en_couple_holder, role = CHEF))
        isole = self.sum_by_entity(isole)

        _0_kid = af_nbenf == 0
        _1_kid = af_nbenf == 1
        _2_kid = af_nbenf == 2
        _3_kid = af_nbenf >= 3

        return period, (0 * (isole & _0_kid) +  # Célibataire
                1 * (not_(isole) & _0_kid) +  # Couple sans enfants
                2 * (not_(isole) & _1_kid) +  # Couple un enfant
                3 * (not_(isole) & _2_kid) +  # Couple deux enfants
                4 * (not_(isole) & _3_kid) +  # Couple trois enfants et plus
                5 * (isole & _1_kid) +  # Famille monoparentale un enfant
                6 * (isole & _2_kid) +  # Famille monoparentale deux enfants
                7 * (isole & _3_kid))  # Famille monoparentale trois enfants et plus

    def function__2009(self, simulation, period):
        """
        Allocation de parent isolé
        """
        period = period.this_month
        age_en_mois_holder = simulation.compute('age_en_mois', period)
        age_holder = simulation.compute('age', period)
        autonomie_financiere_holder = simulation.compute('autonomie_financiere', period)
        isole = not_(simulation.calculate('en_couple', period))
        rsa_forfait_logement = simulation.calculate('rsa_forfait_logement', period)
        rsa_base_ressources = simulation.calculate('rsa_base_ressources', period)
        af_majoration = simulation.calculate('af_majoration', period)
        rsa = simulation.calculate('rsa', period)
        af = simulation.legislation_at(period.start).fam.af
        api = simulation.legislation_at(period.start).minim.api

        age = self.split_by_roles(age_holder, roles = ENFS)
        age_en_mois = self.split_by_roles(age_en_mois_holder, roles = ENFS)
        autonomie_financiere = self.split_by_roles(autonomie_financiere_holder, roles = ENFS)
        # TODO:
        #    Majoration pour isolement
        #    Si vous êtes parent isolé, c’est-à-dire célibataire, divorcé(e), séparé(e) ou veuf(ve) avec des enfants
        #    à charge ou enceinte, le montant forfaitaire garanti est majoré.
        #    Ce montant forfaitaire majoré est accordé à partir du mois au cours duquel survient l'un des événements
        #    suivants :
        #    - déclaration de grossesse,
        #    - naissance d'un enfant,
        #    - prise en charge d'un enfant,
        #    - séparation, veuvage,
        #    - dépôt de la demande si l’événement est antérieur.
        #
        #    Le montant forfaitaire majoré peut être accordé pendant 12 mois, continus ou discontinus, au cours
        #    d’une période de 18 mois suivant l’événement.
        #    Si votre plus jeune enfant à charge a moins de 3 ans, le montant forfaitaire majoré vous est accordé
        #    jusqu'à ses 3 ans.
        benjamin = age_en_mois_benjamin(age_en_mois)
        enceinte = (benjamin < 0) * (benjamin > -6)
        # TODO: quel mois mettre ?
        # TODO: pas complètement exact
        # L'allocataire perçoit l'API :
        # jusqu'�� ce que le plus jeune enfant ait 3 ans,
        # ou pendant 12 mois consécutifs si les enfants sont âgés de plus de 3 ans
        #    et s'il a présenté sa demande dans les 6 mois à partir du moment où il
        #    assure seul la charge de l'enfant.
        # TODO: API courte gens pour les gens qui ont divorcés dans l'année
        # Le droit à l'allocation est réétudié tous les 3 mois.
        # # Calcul de l'année et mois de naissance du benjamin

        condition = (floor(benjamin / 12) <= api.age - 1)
        eligib = isole * ((enceinte != 0) | (nb_enf(age, autonomie_financiere, 0, api.age - 1) > 0)) * condition

        # moins de 20 ans avant inclusion dans rsa
        # moins de 25 ans après inclusion dans rsa
        api1 = eligib * af.bmaf * (api.base + api.enf_sup * nb_enf(age, autonomie_financiere, af.age1, api.age_pac - 1))
        rsa = (api.age_pac >= 25)  # dummy passage au rsa majoré
        br_api = rsa_base_ressources + af_majoration * not_(rsa)
        # On pourrait mensualiser RMI, BRrmi et forfait logement
        api = max_(0, api1 - rsa_forfait_logement / 12 - br_api / 12 - rsa / 12)
        # L'API est exonérée de CRDS
        return period, api  # annualisé

        def ouvre_droit_majoration():
            enceinte_fam = simulation.calculate('enceinte_fam', period)
            isole = not_(simulation.calculate('en_couple', period))
            isolement_recent = simulation.calculate('rsa_isolement_recent', period)
            presence_autres_enfants = self.sum_by_entity(enfant * not_(autonomie_financiere) * (age <= P_rsa.age_pac), entity = "famille") > 1

            return self.cast_from_entity_to_roles(not_(enceinte_fam) * isole * isolement_recent * not_(presence_autres_enfants), entity = 'famille')

def _quaenv_2010_2011(marpac, nb_pac2, f7we, f7wf, f7wg, f7wh, f7wk, f7wq, f7sb, f7sd, f7se, f7sh, rfr, _P):
    '''
    Crédits d’impôt pour dépenses en faveur de la qualité environnementale
    (cases 7WF, 7WH, 7WK, 7WQ, 7SB, 7SD, 7SE et 7SH)
    2010-2011
    '''
    P = _P.ir.credits_impot.quaenv
    max0 = P.max * (1 + marpac) + P.pac1 * nb_pac2

    max1 = max_(0, max0 - f7wf)
    max2 = max_(0, max1 - f7se)
    max3 = max_(0, max2 - f7wk)
    max4 = max_(0, max3 - f7sd)
    max5 = max_(0, max4 - f7wh)
    max6 = max_(0, max5 - f7sb)
    max7 = max_(0, max6 - f7wq)
    return not_(f7wg) * or_(not_(f7we), (rfr < 45000)) * (
                P.taux_wf * min_(f7wf, max0) +
                P.taux_se * min_(f7se, max1) +
                P.taux_wk * min_(f7wk, max2) +
                P.taux_sd * min_(f7sd, max3) +
                P.taux_wh * min_(f7wh, max4) +
                P.taux_sb * min_(f7sb, max5) +
                P.taux_wq * min_(f7wq, max6) +
                P.taux_sh * min_(f7sh, max7))

def _aspa_pure(aspa_elig, marpac, maries, asi_aspa_nb_alloc, br_mv, _P, _option = {'aspa_elig': [CHEF, PART]}):
    '''
    Calcule l'ASPA lorsqu'il y a un ou deux bénéficiaire de l'ASPA et aucun bénéficiaire de l'ASI
    '''
    # La notion de couple change au 1er janvier 2007 (réforme de 2006)
    if _P.datesim.year >= 2007:
        couple = marpac
    else:
        couple = maries

    P = _P.minim

    elig1 = ((asi_aspa_nb_alloc == 1) & (aspa_elig[CHEF] | aspa_elig[PART]))
    elig2 = (aspa_elig[CHEF] & aspa_elig[PART]) * couple  # couple d'allocataire
#     elig = elig1 | elig2
#
#     montant_max = elig1 * P.aspa.montant_seul + elig2 * P.aspa.montant_couple
#     ressources = elig * (br_mv + montant_max)
#     plafond_ressources = elig1 * (P.aspa.plaf_seul * not_(couple) + P.aspa.plaf_couple * couple) + elig2 * P.aspa.plaf_couple
#     depassement = ressources - plafond_ressources
#
#     montant_servi_aspa = max_(montant_max - depassement, 0) / 12

    diff_plaf = P.aspa.plaf_couple - P.aspa.plaf_seul

    plafond_ressources = (elig1 * not_(couple)) * P.aspa.plaf_seul + (elig2 | elig1 * couple) * P.aspa.plaf_couple
    montant_max = (elig1 * not_(couple)) * P.aspa.montant_seul + elig2 * P.aspa.montant_couple + (elig1 * couple) * ((br_mv <= diff_plaf) * (P.aspa.montant_seul + br_mv) + (br_mv > diff_plaf) * P.aspa.montant_couple)
    montant_servi_aspa = max_(montant_max - br_mv, 0) * (br_mv <= plafond_ressources) / 12

    # TODO: Faute de mieux, on verse l'aspa à la famille plutôt qu'aux individus
    # aspa[CHEF] = aspa_elig[CHEF]*montant_servi_aspa*(elig1 + elig2/2)
    # aspa[PART] = aspa_elig[PART]*montant_servi_aspa*(elig1 + elig2/2)

    return 12 * (aspa_elig[CHEF] + aspa_elig[PART]) * montant_servi_aspa * (elig1 + elig2 / 2)  # annualisé

    def function(self, simulation, period):
        period = period.this_month
        last_3_months = period.last_3_months

        # Note Auto-entrepreneurs:
        # D'après les caisses, le revenu pris en compte pour les AE pour le RSA ne prend en compte que
        # l'abattement standard sur le CA, mais pas les cotisations pour charges sociales.

        types_revenus_activite = [
            'salaire_net',
            'indemnites_chomage_partiel',
            'indemnites_volontariat',
            'revenus_stage_formation_pro',
            'bourse_recherche',
            'hsup',
            'etr',
            'tns_auto_entrepreneur_benefice',
            'rsa_indemnites_journalieres_activite',
            ]

        has_ressources_substitution = simulation.calculate('rsa_has_ressources_substitution', period)

        # Les revenus pros interrompus au mois M sont neutralisés s'il n'y a pas de revenus de substitution.
        return period, sum(
            simulation.calculate_add(type_revenu, last_3_months) * not_(
                (simulation.calculate(type_revenu, period.this_month) == 0) *
                (simulation.calculate(type_revenu, period.last_month) > 0) *
                not_(has_ressources_substitution)
                )
            for type_revenu in types_revenus_activite
            ) / 3

        def function(self, simulation, period):
            period = period.start.offset("first-of", "month").period("month")
            age_holder = simulation.compute("age", period)
            # smic55_holder = simulation.compute('smic55', period)
            activite_holder = simulation.compute("activite", period)
            nb_par = simulation.calculate("nb_par", period)
            rmi = simulation.legislation_at(period.start).minim.rmi

            age_parents = self.split_by_roles(age_holder, roles=[CHEF, PART])
            activite_parents = self.split_by_roles(activite_holder, roles=[CHEF, PART])
            # age_enf = self.split_by_roles(age_holder, roles = ENFS)
            # smic55_enf = self.split_by_roles(smic55_holder, roles = ENFS)

            nbp = nb_par

            eligib = ((age_parents[CHEF] >= rmi.age_pac) * not_(activite_parents[CHEF] == 2)) | (
                (age_parents[PART] >= rmi.age_pac) * not_(activite_parents[PART] == 2)
            )

            taux = (
                1
                + (nbp >= 2) * rmi.txp2
                + (nbp >= 3) * rmi.txp3
                + (nbp >= 4) * ((nb_par == 1) * rmi.txps + (nb_par != 1) * rmi.txp3)
                + max_(nbp - 4, 0) * rmi.txps
            )
            return period, eligib * rmi.rmi * taux

    def function(self, simulation, period):
        period = period.this_month
        al = simulation.legislation_at(period.start).al
        couple = simulation.calculate('al_couple', period)
        al_nb_pac = simulation.calculate('al_nb_personnes_a_charge', period)
        residence_dom = simulation.calculate('residence_dom')

        TF_metropole = (
            al.TF.taux1 * (not_(couple)) * (al_nb_pac == 0) +
            al.TF.taux2 * (couple) * (al_nb_pac == 0) +
            al.TF.taux3 * (al_nb_pac == 1) +
            al.TF.taux4 * (al_nb_pac == 2) +
            al.TF.taux5 * (al_nb_pac == 3) +
            al.TF.taux6 * (al_nb_pac >= 4) +
            al.TF.taux7 * (al_nb_pac > 4) * (al_nb_pac - 4)
            )

        TF_dom = (
            al.TF.dom.taux1 * (not_(couple)) * (al_nb_pac == 0) +
            al.TF.dom.taux2 * (couple) * (al_nb_pac == 0) +
            al.TF.dom.taux3 * (al_nb_pac == 1) +
            al.TF.dom.taux4 * (al_nb_pac == 2) +
            al.TF.dom.taux5 * (al_nb_pac == 3) +
            al.TF.dom.taux6 * (al_nb_pac == 4) +
            al.TF.dom.taux7 * (al_nb_pac == 5) +
            al.TF.dom.taux8 * (al_nb_pac >= 6)
        )

        return period, where(residence_dom, TF_dom, TF_metropole)

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')
        rfr = simulation.calculate('rfr', period.start.offset('first-of', 'year').period('year').offset(-2))
        age_holder = simulation.compute('age', period)
        scolarite_holder = simulation.compute('scolarite', period)
        P = simulation.legislation_at(period.start).bourses_education.bourse_college

        ages = self.split_by_roles(age_holder, roles = ENFS)
        nb_enfants = zeros(len(rfr))
        for age in ages.itervalues():
            nb_enfants += age >= 0

        plafond_taux_1 = P.plafond_taux_1 + P.plafond_taux_1 * nb_enfants * P.coeff_enfant_supplementaire
        plafond_taux_2 = P.plafond_taux_2 + P.plafond_taux_2 * nb_enfants * P.coeff_enfant_supplementaire
        plafond_taux_3 = P.plafond_taux_3 + P.plafond_taux_3 * nb_enfants * P.coeff_enfant_supplementaire

        eligible_taux_3 = rfr < plafond_taux_3
        eligible_taux_2 = not_(eligible_taux_3) * (rfr < plafond_taux_2)
        eligible_taux_1 = not_(or_(eligible_taux_2, eligible_taux_3)) * (rfr < plafond_taux_1)

        scolarites = self.split_by_roles(scolarite_holder, roles = ENFS)
        nb_enfants_college = zeros(len(rfr))
        for scolarite in scolarites.itervalues():
            nb_enfants_college += scolarite == SCOLARITE_COLLEGE

        montant = nb_enfants_college * (
            eligible_taux_3 * P.montant_taux_3 +
            eligible_taux_2 * P.montant_taux_2 +
            eligible_taux_1 * P.montant_taux_1
            )

        return period, montant / 12

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')
        three_previous_months = period.start.period('month', 3).offset(-3)
        aspa_elig = simulation.calculate('aspa_elig', period)
        aspa_couple_holder = simulation.compute('aspa_couple', period)
        salaire_de_base = simulation.calculate('salaire_de_base', three_previous_months)
        chonet = simulation.calculate('chonet', three_previous_months)
        rstbrut = simulation.calculate('rstbrut', three_previous_months)
        pensions_alimentaires_percues = simulation.calculate('pensions_alimentaires_percues', three_previous_months)
        rto_declarant1 = simulation.calculate_add_divide('rto_declarant1', three_previous_months)
        rpns = simulation.calculate_add_divide('rpns', three_previous_months)
        rev_cap_bar_holder = simulation.compute_add_divide('rev_cap_bar', three_previous_months)
        rev_cap_lib_holder = simulation.compute_add_divide('rev_cap_lib', three_previous_months)
        rfon_ms = simulation.calculate_add_divide('rfon_ms', three_previous_months)
        div_ms = simulation.calculate_add_divide('div_ms', three_previous_months)
        revenus_stage_formation_pro = simulation.calculate('revenus_stage_formation_pro', three_previous_months)
        allocation_securisation_professionnelle = simulation.calculate('allocation_securisation_professionnelle', three_previous_months)
        prime_forfaitaire_mensuelle_reprise_activite = simulation.calculate('prime_forfaitaire_mensuelle_reprise_activite', three_previous_months)
        dedommagement_victime_amiante = simulation.calculate('dedommagement_victime_amiante', three_previous_months)
        prestation_compensatoire = simulation.calculate('prestation_compensatoire', three_previous_months)
        pensions_invalidite = simulation.calculate('pensions_invalidite', three_previous_months)
        gains_exceptionnels = simulation.calculate('gains_exceptionnels', three_previous_months)
        indemnites_journalieres_maternite = simulation.calculate('indemnites_journalieres_maternite', three_previous_months)
        indemnites_journalieres_maladie = simulation.calculate('indemnites_journalieres_maladie', three_previous_months)
        indemnites_journalieres_maladie_professionnelle = simulation.calculate('indemnites_journalieres_maladie_professionnelle', three_previous_months)
        indemnites_journalieres_accident_travail = simulation.calculate('indemnites_journalieres_accident_travail', three_previous_months)
        indemnites_chomage_partiel = simulation.calculate('indemnites_chomage_partiel', three_previous_months)
        indemnites_volontariat = simulation.calculate('indemnites_volontariat', three_previous_months)
        tns_total_revenus = simulation.calculate_add('tns_total_revenus', three_previous_months)
        rsa_base_ressources_patrimoine_i = simulation.calculate_add('rsa_base_ressources_patrimoine_i', three_previous_months)
        aah = simulation.calculate('aah', three_previous_months)

        legislation = simulation.legislation_at(period.start)
        leg_1er_janvier = simulation.legislation_at(period.start.offset('first-of', 'year'))

        aspa_couple = self.cast_from_entity_to_role(aspa_couple_holder, role = VOUS)
        rev_cap_bar = self.cast_from_entity_to_role(rev_cap_bar_holder, role = VOUS)
        rev_cap_lib = self.cast_from_entity_to_role(rev_cap_lib_holder, role = VOUS)

        # Inclus l'AAH si conjoint non pensionné ASPA, retraite et pension invalidité
        aah = aah * not_(aspa_elig)

        # Abattement sur les salaires (appliqué sur une base trimestrielle)
        abattement_forfaitaire_base = leg_1er_janvier.cotsoc.gen.smic_h_b * legislation.minim.aspa.abattement_forfaitaire_nb_h
        abattement_forfaitaire_taux = (aspa_couple * legislation.minim.aspa.abattement_forfaitaire_tx_couple +
            not_(aspa_couple) * legislation.minim.aspa.abattement_forfaitaire_tx_seul
            )
        abattement_forfaitaire = abattement_forfaitaire_base * abattement_forfaitaire_taux
        salaire_de_base = max_(0, salaire_de_base - abattement_forfaitaire)

        return period, (salaire_de_base + chonet + rstbrut + pensions_alimentaires_percues + rto_declarant1 + rpns +
               max_(0, rev_cap_bar) + max_(0, rev_cap_lib) + max_(0, rfon_ms) + max_(0, div_ms) +
               # max_(0,etr) +
               revenus_stage_formation_pro + allocation_securisation_professionnelle + prime_forfaitaire_mensuelle_reprise_activite +
               dedommagement_victime_amiante + prestation_compensatoire + pensions_invalidite + gains_exceptionnels +
               indemnites_journalieres_maternite + indemnites_journalieres_maladie + indemnites_journalieres_maladie_professionnelle +
               indemnites_journalieres_accident_travail + indemnites_chomage_partiel + indemnites_volontariat + tns_total_revenus +
               rsa_base_ressources_patrimoine_i + aah
               ) / 3

def _br_al(etu, boursier, br_pf_i, rev_coll, biact, _P ,_option = {'boursier': [CHEF, PART], 'etu': [CHEF, PART], 'br_pf_i': [CHEF, PART]}):
    '''
    Base ressource des allocations logement
    '''
    # On ne considère que les revenus des 2 conjoints et les revenus non
    # individualisables
    #   0 - non étudiant
    #   1 - étudiant non boursier
    #   2 - éutidant boursier
    # revCatvous et self.conj : somme des revenus catégoriel après abatement
    # revColl : autres revenus du ménage non individualisable
    # ALabat : abatement prix en compte pour le calcul de la base ressources
    # des allocattions logement
    # plancher de ressources pour les etudiants
    P = _P
    Pr = P.al.ressources

    etuC = (etu[CHEF]) & (not_(etu[PART]))
    etuP = not_(etu[CHEF]) & (etu[PART])
    etuCP = (etu[CHEF]) & (etu[PART])
    # Boursiers
    # TODO: distinguer boursier foyer/boursier locatif
    etuCB = etu[CHEF]&boursier[CHEF]
    etuPB = etu[PART]&boursier[PART]
    # self.etu = (self.etu[CHEF]>=1)|(self.etuP>=1)

    revCatVous = max_(br_pf_i[CHEF],etuC*(Pr.dar_4-(etuCB)*Pr.dar_5))
    revCatConj = max_(br_pf_i[PART],etuP*(Pr.dar_4-(etuPB)*Pr.dar_5))
    revCatVsCj = not_(etuCP)*(revCatVous + revCatConj) + \
                    etuCP*max_(br_pf_i[CHEF] + br_pf_i[PART], Pr.dar_4 -(etuCB|etuPB)*Pr.dar_5 + Pr.dar_7)

    # TODO: ajouter les paramètres pour les étudiants en foyer (boursier et non boursier), les inclure dans le calcul
    # somme des revenus catégoriels après abatement
    revCat = revCatVsCj + rev_coll
    
    # TODO: charges déductibles : pension alimentaires et abatements spéciaux
    revNet = revCat

    # On ne considère pas l'abattement sur les ressources de certaines
    # personnes (enfant, ascendants ou grands infirmes).

    # abattement forfaitaire double activité
    abatDoubleAct = biact*Pr.dar_1

    # TODO: neutralisation des ressources
    # ...

    # TODO: abbattement sur les ressources
    # ...

    # TODO: évaluation forfaitaire des ressources (première demande)

    # TODO :double résidence pour raisons professionnelles

    # Base ressource des aides au logement (arrondies aux 100 euros supérieurs)

    br_al = ceil(max_(revNet - abatDoubleAct,0)/100)*100

    return br_al

    def compare(self, seuil_abs = 100, seuil_rel = 0.10):
        '''
        Fonction qui comparent les calculs d'OF et et de TaxIPP
        Gestion des outputs
        '''
        dta_output = self.paths['dta_output']
        ipp_output = read_stata(dta_output).fillna(0)
        dta_input = self.paths['dta_input']
        ipp_input =  read_stata(dta_input).fillna(0)
        openfisca_output = self.openfisca_outputput.fillna(0)
        openfisca_input = self.simulation.input_table.table
        ipp2of_output_variables = self.dic_var_output

        check_list = ['csg_sal_ded', 'irpp_net_foy', 'af_foys'] # 'csg_sal_ded',
        print self.dic_param
        
        for ipp_var in check_list:
            of_var = ipp2of_output_variables[ipp_var]
            entity = self.simulation.prestation_by_name[of_var].entity
            
            if entity == 'ind':
                conflict = ((ipp_output[ipp_var] - openfisca_output[of_var].abs()).abs() < THRESHOLD)
                print conflict.to_string()
                print ipp_output.loc[not_(conflict), ipp_var].to_string()
                print openfisca_output.loc[not_(conflict), of_var].to_string()
                                
                print ipp_input.loc[not_(conflict), ].to_string()
                print openfisca_input.loc[not_(conflict), self.relevant_input_variables()].to_string()

                #error_diag()
                
                # TODO: finish by calling error_diag
            elif entity == "fam":
            
                pass
            
            
            elif entity == "foy":
                openfisca_foy = openfisca_output.loc[ openfisca_input.quifoy == 0, of_var]             
                ipp_foy = ipp_output.loc[ openfisca_input.quifoy == 0, ipp_var] 
                print ipp_foy

                conflict = ((ipp_foy - openfisca_foy.abs()).abs() > THRESHOLD)
                print conflict.to_string()
                
            elif entity == "men":
                pass
        def _diff(seuil_abs, seuil_rel):
            for k, v in dic.items() :
                diff_abs =  ipp_output[k].mean() - openfisca_output[v].mean()
                
                if diff_abs > seuil_abs :
                    print " Différence absolue pour ", k, ' : ', diff_abs

                diff_rel = (ipp_output.loc[(ipp_output[k] != 0) & (openfisca_output[v] != 0), k] /openfisca_output.loc[(ipp_output[k] != 0) & (openfisca_output[v] != 0), v] ).mean()

                if (diff_rel > seuil_rel) & (diff_rel is not None) :
                    print " Différence relative pour  ", k, ' : ', diff_rel

    def function(self, simulation, period):
        period = period.this_month
        pensions_alimentaires_percues_holder = simulation.compute('pensions_alimentaires_percues', period)
        pensions_alimentaires_percues = self.sum_by_entity(pensions_alimentaires_percues_holder)

        isole = not_(simulation.calculate('en_couple', period))
        residence_mayotte = simulation.calculate('residence_mayotte', period)

        return period, not_(residence_mayotte) * isole * not_(pensions_alimentaires_percues)  # Parent isolé et ne résident pas à Mayotte

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')
        two_years_ago = period.start.offset('first-of', 'year').period('year').offset(-2)
        etu_holder = simulation.compute('etu', period)
        boursier_holder = simulation.compute('boursier', period)
        br_pf_i_holder = simulation.compute('br_pf_i', two_years_ago)
        rev_coll_holder = simulation.compute('rev_coll', two_years_ago)
        biact = simulation.calculate('biact', period)
        Pr = simulation.legislation_at(period.start).al.ressources

        boursier = self.split_by_roles(boursier_holder, roles = [CHEF, PART])
        br_pf_i = self.split_by_roles(br_pf_i_holder, roles = [CHEF, PART])
        etu = self.split_by_roles(etu_holder, roles = [CHEF, PART])
        rev_coll = self.sum_by_entity(rev_coll_holder)
        etuC = (etu[CHEF]) & (not_(etu[PART]))
        etuP = not_(etu[CHEF]) & (etu[PART])
        etuCP = (etu[CHEF]) & (etu[PART])
        # Boursiers
        # TODO: distinguer boursier foyer/boursier locatif
        etuCB = etu[CHEF] & boursier[CHEF]
        etuPB = etu[PART] & boursier[PART]
        # self.etu = (self.etu[CHEF]>=1)|(self.etuP>=1)
        revCatVous = max_(br_pf_i[CHEF], etuC * (Pr.dar_4 - (etuCB) * Pr.dar_5))
        revCatConj = max_(br_pf_i[PART], etuP * (Pr.dar_4 - (etuPB) * Pr.dar_5))
        revCatVsCj = (
            not_(etuCP) * (revCatVous + revCatConj) +
            etuCP * max_(br_pf_i[CHEF] + br_pf_i[PART], Pr.dar_4 - (etuCB | etuPB) * Pr.dar_5 + Pr.dar_7)
            )

        # TODO: ajouter les paramètres pour les étudiants en foyer (boursier et non boursier),
        # les inclure dans le calcul somme des revenus catégoriels après abatement
        revCat = revCatVsCj + rev_coll

        # TODO: charges déductibles : pension alimentaires et abatements spéciaux
        revNet = revCat

        # On ne considère pas l'abattement sur les ressources de certaines
        # personnes (enfant, ascendants ou grands infirmes).

        # abattement forfaitaire double activité
        abatDoubleAct = biact * Pr.dar_1

        # TODO: neutralisation des ressources
        # ...

        # TODO: abbattement sur les ressources
        # ...

        # TODO: évaluation forfaitaire des ressources (première demande)

        # TODO :double résidence pour raisons professionnelles

        # Base ressource des aides au logement (arrondies aux 100 euros supérieurs)

        br_al = ceil(max_(revNet - abatDoubleAct, 0) / 100) * 100

        return period, br_al

    def function(famille, period):
        period = period.this_month
        pensions_alimentaires_percues = famille.members('pensions_alimentaires_percues', period)
        pas_de_pensions = not_(famille.sum(pensions_alimentaires_percues))

        isole = not_(famille('en_couple', period))
        residence_mayotte = famille.demandeur.menage('residence_mayotte', period)

        return period, not_(residence_mayotte) * isole * pas_de_pensions  # Parent isolé et ne résident pas à Mayotte

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')
        pensions_alimentaires_percues_holder = simulation.compute('pensions_alimentaires_percues', period)
        pensions_alimentaires_percues = self.sum_by_entity(pensions_alimentaires_percues_holder)

        isol = simulation.calculate('isol', period)
        residence_mayotte = simulation.calculate('residence_mayotte', period)

        return period, not_(residence_mayotte) * isol * not_(pensions_alimentaires_percues)  # Parent isolé et ne résident pas à Mayotte