def attribution(self, assiette, getT = False):
     '''
     renvoie un vecteur associant les bonnes valeurs de la variable (selon génération)
     '''
     k = self.nb
     n = len(assiette)
     if not self._linear_taux_moy:
         assi = np.tile(assiette, (k, 1)).T
         seui = np.tile(np.hstack((self.seuils, np.inf)), (n, 1))
         a = max_(min_(assi, seui[:, 1:]) - seui[:, :-1], 0)
         i = np.dot(self.taux, a.T)
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i
     else:
         if len(self.tauxM) == 1:
             i = assiette * self.tauxM[0]
         else:
             assi = np.tile(assiette, (k - 1, 1)).T
             seui = np.tile(np.hstack(self.seuils), (n, 1))
             k = self.t_x().T
             a = (assi >= seui[:, :-1]) * (assi < seui[:, 1:])
             A = np.dot(a, self.t_x().T)
             B = np.dot(a, np.array(self.seuils[1:]))
             C = np.dot(a, np.array(self.tauxM[:-1]))
             i = assiette * (A * (assiette - B) + C) + max_(assiette - self.seuils[-1], 0) * self.tauxM[-1] + (assiette >= self.seuils[-1]) * self.seuils[-1] * self.tauxM[-2]
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i

def _aefa(age, smic55, af_nbenf, nb_par, ass ,aer, api, rsa, _P, _option = {'age': ENFS, 'smic55': ENFS}):
    '''
    Aide exceptionelle de fin d'année (prime de Noël)
    '''
    # Insituée en 1998        
    # Apparaît sous le nom de complément de rmi dans les ERF    
    P = _P
    dummy_ass = ass > 0
    dummy_aer = aer > 0
    dummy_api = api > 0
    dummy_rmi = rsa > 0

    # Le montant de l’aide mentionnée à l’article 1er versée aux bénéficiaires de l’allocation de solidarité
    # spécifique à taux majoré servie aux allocataires âgés de cinquante-cinq ans ou plus justifiant de vingt années
    # d’activité salariée, aux allocataires âgés de cinquante-sept ans et demi ou plus justifiant de dix années d’activité
    # salariée ainsi qu’aux allocataires justifiant d’au moins 160 trimestres validés dans les régimes d’assurance
    # vieillesse ou de périodes reconnues équivalentes est égal à        
    maj = 0  # TODO
    
    condition = (dummy_ass+dummy_aer+dummy_api+dummy_rmi > 0)
    
    if hasattr(P.fam.af,"age3"): nbPAC = nb_enf(age, smic55, P.fam.af.age1,P.fam.af.age3)
    else: nbPAC = af_nbenf
    # TODO check nombre de PAC pour une famille
    P = _P.minim
    aefa = condition*P.aefa.mon_seul*(1 + (nb_par==2)*P.aefa.tx_2p
              + nbPAC*P.aefa.tx_supp*(nb_par<=2)
              + nbPAC*P.aefa.tx_3pac*max_(nbPAC-2,0))
    
    if _P.datesim.year==2008: aefa += condition*P.aefa.forf2008
               
    aefa_maj  = P.aefa.mon_seul*maj
    aefa = max_(aefa_maj,aefa)   
    return aefa 

 def calculate(self, base, getT = False):
     '''
     Computes the tax using a a nonlinear tax scale using marginal tax rates
     Note: base is the base of the tax, in column
     '''
     k = self.nb
     n = len(base)
     if not self._linear_avg_rate:
         assi = np.tile(base, (k, 1)).T
         seui = np.tile(np.hstack((self.thresholds, np.inf)), (n, 1))
         a = max_(min_(assi, seui[:, 1:]) - seui[:, :-1], 0)
         i = np.dot(self.rates, a.T)
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i
     else:
         if len(self.rates_average) == 1:
             i = base * self.rates_average[0]
         else:
             assi = np.tile(base, (k - 1, 1)).T
             seui = np.tile(np.hstack(self.thresholds), (n, 1))
             k = self.t_x().T
             a = (assi >= seui[:, :-1]) * (assi < seui[:, 1:])
             A = np.dot(a, self.t_x().T)
             B = np.dot(a, np.array(self.thresholds[1:]))
             C = np.dot(a, np.array(self.rates_average[:-1]))
             i = base * (A * (base - B) + C) + max_(base - self.thresholds[-1], 0) * self.rates_average[-1] + (base >= self.thresholds[-1]) * self.thresholds[-1] * self.rates_average[-2]
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i

    def function(self, simulation, period):
        period = period.this_month
        rev_coll_holder = simulation.compute('rev_coll', period.n_2)
        rev_coll = self.sum_by_entity(rev_coll_holder)
        biact = simulation.calculate('biact', period)
        Pr = simulation.legislation_at(period.start).al.ressources
        br_pf_i_holder = simulation.compute('br_pf_i', period)
        br_pf_parents = self.sum_by_entity(br_pf_i_holder, roles = [CHEF, PART])
        abattement_chomage_indemnise_holder = simulation.compute('aide_logement_abattement_chomage_indemnise', period)
        abattement_chomage_indemnise = self.sum_by_entity(abattement_chomage_indemnise_holder, roles = [CHEF, PART])
        abattement_depart_retraite_holder = simulation.compute('aide_logement_abattement_depart_retraite', period)
        abattement_depart_retraite = self.sum_by_entity(abattement_depart_retraite_holder, roles = [CHEF, PART])
        neutralisation_rsa = simulation.calculate('aide_logement_neutralisation_rsa', period)
        abattement_ressources_enfant = simulation.legislation_at(period.n_2.stop).minim.aspa.plaf_seul * 1.25
        br_enfants = self.sum_by_entity(
            max_(0, br_pf_i_holder.array - abattement_ressources_enfant), roles = ENFS)
        ressources = (
            br_pf_parents + br_enfants + rev_coll -
            (abattement_chomage_indemnise + abattement_depart_retraite + neutralisation_rsa)
        )

        # Abattement forfaitaire pour double activité
        abattement_double_activite = biact * Pr.dar_1

        # Arrondi aux 100 euros supérieurs
        result = max_(ressources - abattement_double_activite, 0)

        return period, result

    def function_2009__(self, simulation, period):
        period = period.this_year
        age_holder = simulation.compute('age', period)
        smic55_holder = simulation.compute('smic55', period, accept_other_period = True)
        af_nbenf = simulation.calculate('af_nbenf', period)
        nb_par = simulation.calculate('nb_par', period)
        ass = simulation.calculate_add('ass', period)
        aer_holder = simulation.compute('aer', period)
        api = simulation.calculate_add('api', period)
        rsa = simulation.calculate_add('rsa', period)
        P = simulation.legislation_at(period.start).minim.aefa
        af = simulation.legislation_at(period.start).fam.af

        age = self.split_by_roles(age_holder, roles = ENFS)
        aer = self.sum_by_entity(aer_holder)
        smic55 = self.split_by_roles(smic55_holder, roles = ENFS)
        dummy_ass = ass > 0
        dummy_aer = aer > 0
        dummy_api = api > 0
        dummy_rmi = rsa > 0
        maj = 0  # TODO
        condition = (dummy_ass + dummy_aer + dummy_api + dummy_rmi > 0)
        if hasattr(af, "age3"):
            nbPAC = nb_enf(age, smic55, af.age1, af.age3)
        else:
            nbPAC = af_nbenf
        # TODO check nombre de PAC pour une famille
        aefa = condition * P.mon_seul * (
            1 + (nb_par == 2) * P.tx_2p +
            nbPAC * P.tx_supp * (nb_par <= 2) +
            nbPAC * P.tx_3pac * max_(nbPAC - 2, 0)
            )
        aefa_maj = P.mon_seul * maj
        aefa = max_(aefa_maj, aefa)
        return period, aefa

def _apje(br_pf, age, smic55, isol, biact, _P, _option={'age': ENFS, 'smic55': ENFS}):
    '''
    Allocation pour jeune enfant
    '''
    # TODO: APJE courte voir doc ERF 2006
    P = _P.fam
    nbenf = nb_enf(age, smic55, 0, P.apje.age - 1)
    bmaf = P.af.bmaf
    bmaf_n_2 = P.af.bmaf_n_2
    base = round(P.apje.taux * bmaf, 2)
    base2 = round(P.apje.taux * bmaf_n_2, 2)

    plaf_tx = (nbenf > 0) + P.apje.plaf_tx1 * min_(nbenf, 2) + P.apje.plaf_tx2 * max_(nbenf - 2, 0)
    majo = isol | biact
    plaf = P.apje.plaf * plaf_tx + P.apje.plaf_maj * majo
    plaf2 = plaf + 12 * base2

    apje = (nbenf >= 1) * ((br_pf <= plaf) * base
                            + (br_pf > plaf) * max_(plaf2 - br_pf, 0) / 12.0)

    # Pour bénéficier de cette allocation, il faut que tous les enfants du foyer soient nés, adoptés, ou recueillis en vue d’une adoption avant le 1er janvier 2004, et qu’au moins l’un d’entre eux ait moins de 3 ans.
    # Cette allocation est verséE du 5ème mois de grossesse jusqu’au mois précédant le 3ème anniversaire de l’enfant.

    # Non cumul APE APJE CF
    #  - L’allocation parentale d’éducation (APE), sauf pour les femmes enceintes.
    #    L’APJE est alors versée du 5ème mois de grossesse jusqu’à la naissance de l’enfant.
    #  - Le CF
    return 12*apje  # annualisé

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')
        apl = simulation.calculate('apl', period)
        als = simulation.calculate('als', period)
        alf = simulation.calculate('alf', period)

        return period, max_(max_(apl, als), alf)

    def function(self, simulation, period):
        period = period.this_month
        chomage_brut = simulation.calculate('chomage_brut', period)
        csg_deductible_chomage = simulation.calculate('csg_deductible_chomage', period)
        csg_imposable_chomage = simulation.calculate('csg_imposable_chomage', period)
        taux_csg_remplacement = simulation.calculate('taux_csg_remplacement', period)
        law = simulation.legislation_at(period.start)

        smic_h_b = law.cotsoc.gen.smic_h_b
        # salaire_mensuel_reference = chomage_brut / .7
        # heures_mensuelles = min_(salaire_mensuel_reference / smic_h_b, 35 * 52 / 12)  # TODO: depuis 2001 mais avant ?
        heures_mensuelles = 35 * 52 / 12
        cho_seuil_exo = law.csg.chomage.min_exo * heures_mensuelles * smic_h_b

        montant_crds = montant_csg_crds(
            base_avec_abattement = chomage_brut,
            law_node = law.crds.activite,
            plafond_securite_sociale = law.cotsoc.gen.plafond_securite_sociale,
            ) * (2 <= taux_csg_remplacement)

        crds_chomage = max_(
            -montant_crds - max_(
                cho_seuil_exo - (chomage_brut + csg_imposable_chomage + csg_deductible_chomage + montant_crds), 0
                ), 0
            )
        return period, -crds_chomage

    def function__2008_(self, simulation, period):
        period = period.this_year
        af_nbenf = simulation.calculate('af_nbenf', period)
        nb_parents = simulation.calculate('nb_parents', period)
        ass = simulation.calculate_add('ass', period)
        aer_holder = simulation.compute('aer', period)
        api = simulation.calculate_add('api', period)
        rsa = simulation.calculate('rsa', period)
        P = simulation.legislation_at(period.start).prestations.minima_sociaux.aefa
        af = simulation.legislation_at(period.start).prestations.prestations_familiales.af

        aer = self.sum_by_entity(aer_holder)
        dummy_ass = ass > 0
        dummy_aer = aer > 0
        dummy_api = api > 0
        dummy_rmi = rsa > 0
        maj = 0  # TODO
        condition = (dummy_ass + dummy_aer + dummy_api + dummy_rmi > 0)
        if hasattr(af, "age3"):
            nbPAC = nb_enf(simulation.famille, period, af.age1, af.age3)
        else:
            nbPAC = af_nbenf
        # TODO check nombre de PAC pour une famille
        aefa = condition * P.mon_seul * (
            1 + (nb_parents == 2) * P.tx_2p +
            nbPAC * P.tx_supp * (nb_parents <= 2) +
            nbPAC * P.tx_3pac * max_(nbPAC - 2, 0)
            )
        aefa_maj = P.mon_seul * maj
        aefa = max_(aefa_maj, aefa)
        return period, aefa

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'year').period('year')
        frag_impo = simulation.calculate('frag_impo', period)
        nrag_impg = simulation.calculate('nrag_impg', period)
        nbic_impn = simulation.calculate('nbic_impn', period)
        nbic_imps = simulation.calculate('nbic_imps', period)
        nbic_defn = simulation.calculate('nbic_defn', period)
        nbic_defs = simulation.calculate('nbic_defs', period)
        nacc_impn = simulation.calculate('nacc_impn', period)
        nacc_meup = simulation.calculate('nacc_meup', period)
        nacc_defn = simulation.calculate('nacc_defn', period)
        nacc_defs = simulation.calculate('nacc_defs', period)
        nbnc_impo = simulation.calculate('nbnc_impo', period)
        nbnc_defi = simulation.calculate('nbnc_defi', period)
        P = simulation.legislation_at(period.start).ir.rpns

        nbic_timp = (nbic_impn + nbic_imps) - (nbic_defn + nbic_defs)

        # C revenus industriels et commerciaux non professionnels
        # (revenus accesoires du foyers en nomenclature INSEE)
        nacc_timp = max_(0, (nacc_impn + nacc_meup) - (nacc_defn + nacc_defs))

        # régime de la déclaration contrôlée ne bénéficiant pas de l'abattement association agréée
        nbnc_timp = nbnc_impo - nbnc_defi

        # Totaux
        ntimp = nrag_impg + nbic_timp + nacc_timp + nbnc_timp

        return period, max_(0, P.cga_taux2 * (ntimp + frag_impo))

def _cf(age, br_pf, isol, biact, smic55, _P, _option={'age': ENFS, 'smic55': ENFS}):
    """
    Complément familial
    Vous avez au moins 3 enfants à charge tous âgés de plus de 3 ans.
    Vos ressources ne dépassent pas certaines limites.
    Vous avez peut-être droit au Complément Familial à partir du mois
    suivant les 3 ans du 3ème, 4ème, etc. enfant.

    # TODO:
    # En théorie, il faut comparer les revenus de l'année n-2 à la bmaf de
    # l'année n-2 pour déterminer l'éligibilité avec le cf_seuil. Il faudrait
    # pouvoir déflater les revenus de l'année courante pour en tenir compte.
    """
    P = _P.fam
    bmaf = P.af.bmaf
    bmaf2 = P.af.bmaf_n_2
    cf_nbenf = nb_enf(age, smic55, P.cf.age1, P.cf.age2)

    cf_base_n_2 = P.cf.tx * bmaf2
    cf_base = P.cf.tx * bmaf

    cf_plaf_tx = 1 + P.cf.plaf_tx1 * min_(cf_nbenf, 2) + P.cf.plaf_tx2 * max_(cf_nbenf - 2, 0)
    cf_majo = isol | biact
    cf_plaf = P.cf.plaf * cf_plaf_tx + P.cf.plaf_maj * cf_majo
    cf_plaf2 = cf_plaf + 12 * cf_base_n_2

    cf = (cf_nbenf >= 3) * ((br_pf <= cf_plaf) * cf_base +
                             (br_pf > cf_plaf) * max_(cf_plaf2 - br_pf, 0) / 12.0)
    return 12 * cf

 def calc(self, assiette, getT = False):
     '''
     Calcule un impôt selon le barême non linéaire exprimé en tranches de taux marginaux.
     'assiette' est l'assiette de l'impôt, en colonne
     '''
     k = self.nb
     n = len(assiette)
     if not self._linear_taux_moy:
         assi = np.tile(assiette, (k, 1)).T
         seui = np.tile(np.hstack((self.seuils, np.inf)), (n, 1))
         a = max_(min_(assi, seui[:, 1:]) - seui[:, :-1], 0)
         i = np.dot(self.taux, a.T)
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i
     else:
         if len(self.tauxM) == 1:
             i = assiette * self.tauxM[0]
         else:
             assi = np.tile(assiette, (k - 1, 1)).T
             seui = np.tile(np.hstack(self.seuils), (n, 1))
             k = self.t_x().T
             a = (assi >= seui[:, :-1]) * (assi < seui[:, 1:])
             A = np.dot(a, self.t_x().T)
             B = np.dot(a, np.array(self.seuils[1:]))
             C = np.dot(a, np.array(self.tauxM[:-1]))
             i = assiette * (A * (assiette - B) + C) + max_(assiette - self.seuils[-1], 0) * self.tauxM[-1] + (assiette >= self.seuils[-1]) * self.seuils[-1] * self.tauxM[-2]
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i

def _prcomp(f7wm, f7wn, f7wo, f7wp, _P):
    """
    Prestations compensatoires
    2002-2010
    """
    P = _P.ir.reductions_impots.prcomp
    div = (f7wo == 0) * 1 + f7wo  # Pour éviter les divisions par zéro

    return (
        (f7wm == 0)
        * (
            (f7wn == f7wo) * P.taux * min_(f7wn, P.seuil)
            + (f7wn < f7wo) * (f7wo <= P.seuil) * P.taux * f7wn
            + max_(0, (f7wn < f7wo) * (f7wo > P.seuil) * P.taux * P.seuil * f7wn / div)
            + P.taux * f7wp
        )
        + (f7wm != 0)
        * (
            (f7wn == f7wm) * (f7wo <= P.seuil) * P.taux * f7wm
            + max_(0, (f7wn == f7wm) * (f7wo >= P.seuil) * P.taux * f7wm / div)
            + (f7wn > f7wm) * (f7wo <= P.seuil) * P.taux * f7wn
            + max_(0, (f7wn > f7wm) * (f7wo >= P.seuil) * P.taux * f7wn / div)
        )
        + P.taux * f7wp
    )

def _ars(self, age_holder, af_nbenf, smic55_holder, br_pf, P = law.fam):
    '''
    Allocation de rentrée scolaire brute de CRDS
    '''
    # TODO: convention sur la mensualisation
    # On tient compte du fait qu'en cas de léger dépassement du plafond, une allocation dégressive
    # (appelée allocation différentielle), calculée en fonction des revenus, peut être versée.
    age = self.split_by_roles(age_holder, roles = ENFS)
    smic55 = self.split_by_roles(smic55_holder, roles = ENFS)

    bmaf = P.af.bmaf
    # On doit prendre l'âge en septembre
    enf_05 = nb_enf(age, smic55, P.ars.agep - 1, P.ars.agep - 1)  # 5 ans et 6 ans avant le 31 décembre
    # enf_05 = 0
    # Un enfant scolarisé qui n'a pas encore atteint l'âge de 6 ans
    # avant le 1er février 2012 peut donner droit à l'ARS à condition qu'il
    # soit inscrit à l'école primaire. Il faudra alors présenter un
    # certificat de scolarité.
    enf_primaire = enf_05 + nb_enf(age, smic55, P.ars.agep, P.ars.agec - 1)
    enf_college = nb_enf(age, smic55, P.ars.agec, P.ars.agel - 1)
    enf_lycee = nb_enf(age, smic55, P.ars.agel, P.ars.ages)

    arsnbenf = enf_primaire + enf_college + enf_lycee

    # Plafond en fonction du nb d'enfants A CHARGE (Cf. article R543)
    ars_plaf_res = P.ars.plaf * (1 + af_nbenf * P.ars.plaf_enf_supp)
    arsbase = bmaf * (P.ars.tx0610 * enf_primaire +
                     P.ars.tx1114 * enf_college +
                     P.ars.tx1518 * enf_lycee)
    # Forme de l'ARS  en fonction des enfants a*n - (rev-plaf)/n
    # ars_diff = (ars_plaf_res + arsbase - br_pf) / arsnbenf
    ars = (arsnbenf > 0) * max_(0, arsbase - max_(0, (br_pf - ars_plaf_res) / max_(1, arsnbenf)))
    # Calcul net de crds : ars_net = (P.ars.enf0610 * enf_primaire + P.ars.enf1114 * enf_college + P.ars.enf1518 * enf_lycee)

    return ars * (ars >= P.ars.seuil_nv)

    def function(self, simulation, period):
        period = period.this_month
        biactivite = simulation.calculate('biactivite', period)
        Pr = simulation.legislation_at(period.start).prestations.aides_logement.ressources
        base_ressources_holder = simulation.compute('prestations_familiales_base_ressources_individu', period)
        base_ressources_parents = self.sum_by_entity(base_ressources_holder, roles = [CHEF, PART])
        abattement_chomage_indemnise_holder = simulation.compute('aide_logement_abattement_chomage_indemnise', period)
        abattement_chomage_indemnise = self.sum_by_entity(abattement_chomage_indemnise_holder, roles = [CHEF, PART])
        abattement_depart_retraite_holder = simulation.compute('aide_logement_abattement_depart_retraite', period)
        abattement_depart_retraite = self.sum_by_entity(abattement_depart_retraite_holder, roles = [CHEF, PART])
        neutralisation_rsa = simulation.calculate('aide_logement_neutralisation_rsa', period)
        abattement_ressources_enfant = simulation.legislation_at(period.n_2.stop).prestations.minima_sociaux.aspa.plafond_ressources_seul * 1.25
        br_enfants = self.sum_by_entity(
            max_(0, base_ressources_holder.array - abattement_ressources_enfant), roles = ENFS)

        # Revenus du foyer fiscal
        rev_coll = simulation.famille.demandeur.foyer_fiscal('rev_coll', period.n_2)

        ressources = (
            base_ressources_parents + br_enfants + rev_coll -
            (abattement_chomage_indemnise + abattement_depart_retraite + neutralisation_rsa)
            )

        # Abattement forfaitaire pour double activité
        abattement_double_activite = biactivite * Pr.dar_1

        # Arrondi aux 100 euros supérieurs
        result = max_(ressources - abattement_double_activite, 0)

        return period, result

def _ars(age, smic55, br_pf, _P, _option={'age': ENFS, 'smic55': ENFS}):
    '''
    Allocation de rentrée scolaire
    '''
    # TODO: convention sur la mensualisation
    # On tient compte du fait qu'en cas de léger dépassement du plafond, une allocation dégressive
    # (appelée allocation différentielle), calculée en fonction des revenus, peut être versée.

    P = _P.fam
    bmaf = P.af.bmaf
    # On doit prendre l'âge en septembre
    enf_05 = nb_enf(age, smic55, P.ars.agep - 1, P.ars.agep - 1)  # 6 ans avant le 31 décembre
    #enf_05 = 0
    # Un enfant scolarisé qui n'a pas encore atteint l'âge de 6 ans
    # avant le 1er février 2012 peut donner droit à l'ARS à condition qu'il
    # soit inscrit à l'école primaire. Il faudra alors présenter un
    # certificat de scolarité.
    enf_primaire = enf_05 + nb_enf(age, smic55, P.ars.agep, P.ars.agec - 1)
    enf_college = nb_enf(age, smic55, P.ars.agec, P.ars.agel - 1)
    enf_lycee = nb_enf(age, smic55, P.ars.agel, P.ars.ages)

    arsnbenf = enf_primaire + enf_college + enf_lycee

    ars_plaf_res = P.ars.plaf * (1 + arsnbenf * P.ars.plaf_enf_supp)
    arsbase = bmaf * (P.ars.tx0610 * enf_primaire +
                     P.ars.tx1114 * enf_college +
                     P.ars.tx1518 * enf_lycee)
    # Forme de l'ARS  en fonction des enfants a*n - (rev-plaf)/n
    ars = max_(0, (ars_plaf_res + arsbase * arsnbenf - max_(br_pf, ars_plaf_res)) / max_(1, arsnbenf))
    return ars * (ars >= P.ars.seuil_nv)

    def function_2005_07_01(self, simulation, period):
        period = period.this_month
        law = simulation.legislation_at(period.start)

        grph = law.minim.caah.grph
        aah_montant = law.minim.aah.montant

        aah = simulation.calculate('aah', period)
        asi_eligibilite = simulation.calculate('asi_eligibilite', period)
        asi_holder = simulation.compute('asi', period)  # montant asi de la famille
        asi = self.cast_from_entity_to_roles(asi_holder)  # attribué à tous les membres de la famille
        benef_asi = (asi_eligibilite * (asi > 0))
        al_holder = simulation.compute('aide_logement_montant', period)  # montant allocs logement de la famille
        al = self.cast_from_entity_to_roles(al_holder)  # attribué à tout individu membre de la famille

        elig_cpl = ((aah > 0) | (benef_asi > 0))
        # TODO: & logement indépendant & inactif 12 derniers mois
        # & capa de travail < 5% & taux d'incapacité >= 80%
        compl_ress = elig_cpl * max_(grph - aah_montant, 0)

        elig_mva = (al > 0) * ((aah > 0) | (benef_asi > 0))
        # TODO: & logement indépendant & pas de revenus professionnels
        # propres & capa de travail < 5% & taux d'incapacité >= 80%
        mva = 0.0 * elig_mva  # TODO: rentrer mva dans paramètres. mva (mensuelle) = 104,77 en 2015, était de 101,80 en 2006, et de 119,72 en 2007

        return period, max_(compl_ress, mva)

def _plus_values(f3vg, f3vh, f3vl, f3vm, f3vi, f3vf, f3vd, f3sd, f3si, f3sf, f3sa, rpns_pvce, _P):
    """
    Taxation des plus value
    TODO: f3vt, 2013 f3Vg au barème / tout refaire
    """
    P = _P.ir.plus_values
        # revenus taxés à un taux proportionnel
    rdp = max_(0, f3vg - f3vh) + f3vl + rpns_pvce + f3vm + f3vi + f3vf
    out = (P.pvce * rpns_pvce +
           P.taux1 * max_(0, f3vg - f3vh) +
           P.caprisque * f3vl +
           P.pea * f3vm +
           P.taux3 * f3vi +
           P.taux4 * f3vf)
    if _P.datesim.year >= 2008:
        # revenus taxés à un taux proportionnel
        rdp += f3vd
        out += P.taux1 * f3vd
    if _P.datesim.year == 2012:
        out = P.taux2 * f3vd + P.taux3 * f3vi + P.taux4 * f3vf + P.taux1 * max_(0, f3vg - f3vh)
        out = (P.taux2 * (f3vd + f3sd) + P.taux3 * (f3vi + f3si) +
               P.taux4 * (f3vf + f3sf) + P.taux1 * max_(0, f3vg - f3vh) + P.pvce * f3sa)  # TODO: chek this rpns missing ?
    if _P.datesim.year > 2012:
        out = f3vg * 0  # TODO: completely undone

    return round(out)

def _aidper(marpac, nb_pac2, f7wf, f7wi, f7wj, f7wl, f7sf, f7si, _P):
    '''
    Crédits d’impôt pour dépenses en faveur de l’aide aux personnes
    (cases 7WI, 7WJ, 7WL et 7SF).
    2002-
    '''
    P = _P.ir.credits_impot.aidper

    n = nb_pac2
    if _P.datesim.year <= 2005:
        max0 = P.max * (1 + marpac) + P.pac1 * (n >= 1) + P.pac2 * (n >= 2) + P.pac2 * (max_(n - 2, 0))

    elif _P.datesim.year >= 2006:
        max0 = P.max * (1 + marpac) + P.pac1 * n

    if _P.datesim.year in (2002, 2003):
        return P.taux_wi * min_(f7wi, max0)  # TODO: enfant en résidence altérnée
    elif _P.datesim.year <= 2009:
        max1 = max_(0, max0 - f7wj)
        return (P.taux_wj * min_(f7wj, max0) +
                P.taux_wi * min_(f7wi, max1))
    elif _P.datesim.year == 2010:
        max1 = max_(0, max0 - f7wl)
        max2 = max_(0, max1 - f7sf)
        max3 = max_(0, max2 - f7wj)
        return (P.taux_wl * min_(f7wl, max0) +
                P.taux_sf * min_(f7sf, max1) +
                P.taux_wj * min_(f7wj, max2) +
                P.taux_wi * min_(f7si, max3))
    else:
        return 0 * marpac  # TODO 2011, 2012, 2013

def _rev_cat_rvcm(marpac, deficit_rcm, f2ch, f2dc, f2ts, f2ca, f2fu, f2go, f2gr, f2tr, _P):
    ''' REVENUS DES VALEURS ET CAPITAUX MOBILIERS '''
    P = _P.ir.rvcm
    if _P.datesim.year > 2004: f2gr = 0

    ## Calcul du revenu catégoriel
    #1.2 Revenus des valeurs et capitaux mobiliers
    b12 = min_(f2ch, P.abat_assvie*(1 + marpac))
    TOT1 = f2ch-b12
    # Part des frais s'imputant sur les revenus déclarés case DC
    den = ((f2dc + f2ts)!=0)*(f2dc + f2ts) + ((f2dc + f2ts)==0)
    F1 =  f2ca/den*f2dc
    
    # Revenus de capitaux mobiliers nets de frais, ouvrant droit à abattement
    # partie négative (à déduire des autres revenus nets de frais d'abattements
    g12a = - min_(f2dc*P.abatmob_taux - F1,0)
    # partie positive
    g12b = max_(f2dc*P.abatmob_taux - F1,0)
    
    rev = g12b + f2gr + f2fu*P.abatmob_taux

    # Abattements, limité au revenu
    h12 = P.abatmob*(1 + marpac)
    TOT2 = max_(0,rev - h12)
    i121= -min_(0,rev - h12)
    
    # Pars des frais s'imputant sur les revenus déclarés ligne TS
    F2 = f2ca - F1
    TOT3 = (f2ts - F2) + f2go*P.majGO + f2tr - g12a

    DEF = deficit_rcm

    return max_(TOT1 + TOT2 + TOT3 - DEF, 0)