/**
  * torna il tipo di atto, per quello che concerne il calcolo dell'indice di attività
  *
  * @return string
  * @author Guglielmo Celata
  */
 public function getTipoPerIndice()
 {
     return OppTipoAttoPeer::getTipoPerIndice($this->getTipoAttoId());
 }
 /**
  * calcola l'indice di rilevanza, per un atto, nel suo complesso
  *
  * @param integer $atto_id
  * @param integer $tipo_atto_id 
  * @param date $data 
  * @param SimpleXMLElement    $xml_node   
  * @param boolean   $verbose
  * @return float
  * @author Guglielmo Celata
  */
 public static function calcolaRilevanzaAtto($atto, $tipo_atto_id, $data, $xml_node, $verbose = false)
 {
     $atto_node = $xml_node->addChild('atto', null, self::$opp_ns);
     $atto_id = $atto->getId();
     // calcolo gruppi e schieramenti che presentano
     list($schier_pres, $grup_pres) = OppCaricaHasAttoPeer::getSchierGrupPresAtto($atto_id, $data);
     if ($verbose) {
         printf("\n    presentazione:\n");
         printf("      schieramenti: %s\n", join(',', $schier_pres));
         printf("      gruppi: %s\n", join(',', $grup_pres));
     }
     // il peso di un atto non dipende mai da chi lo ha presentato
     // il coefficiente che si considera è sempre quello di maggioranza
     $di_maggioranza = true;
     // determina la priorità dell'atto
     $priorita = is_null($atto->getPriorityValue()) ? 1 : $atto->getPriorityValue();
     $atto_is_ratifica = $atto->isRatifica();
     // determina il tipo di atto (per quello che concerne il calcolo dell'indice)
     $tipo_atto = OppTipoAttoPeer::getTipoPerIndice($tipo_atto_id);
     if (is_null($tipo_atto)) {
         return 0;
     }
     $atto_node->addAttribute('tipo_atto', $tipo_atto);
     $atto_node->addAttribute('priorita', $priorita);
     $atto_node->addAttribute('id', $atto_id);
     $punteggio = 0.0;
     // punteggio dato all'atto per-se, a seconda del tipo
     if ($tipo_atto == 'SDDL') {
         $punteggio = 1.0;
     } else {
         $punteggio = 0.5;
     }
     $presentazione_node = $atto_node->addChild('presentazione', null, self::$opp_ns);
     $presentazione_node->addAttribute('totale', $punteggio);
     // --- consenso ---
     $consenso_node = $atto_node->addChild('consenso', null, self::$opp_ns);
     $firmeRS = OppCaricaHasAttoPeer::getFirmeAttoDataTipoRS($atto_id, $data, "'C'");
     $n_firme = array('gruppo' => 0, 'altri' => 0, 'opp' => 0);
     while ($firmeRS->next()) {
         $row = $firmeRS->getRow();
         if ($verbose) {
             printf("    %d firme per gruppo %d\n", $row['nf'], $row['gruppo_id']);
         }
         // gestione del caso in cui l'atto è presentato dai due schieramenti
         // tutte le firme sono assegnate a gruppo, altri e opp
         if (count($schier_pres) > 1) {
             $n_firme['gruppo'] += $row['nf'];
             $n_firme['altri'] += $row['nf'];
             $n_firme['opp'] += $row['nf'];
             continue;
         }
         // gestione del caso in cui l'atto è presentato da più di un gruppo
         // le firme dello schieramento di pres. sono assegnate a gruppo e altri
         if (count($grup_pres) > 1) {
             if ($row['maggioranza'] == $schier_pres[0]) {
                 $n_firme['gruppo'] += $row['nf'];
                 $n_firme['altri'] += $row['nf'];
             } else {
                 $n_firme['opp'] += $row['nf'];
             }
             continue;
         }
         if (in_array($row['gruppo_id'], $grup_pres)) {
             if ($row['nf'] > 1) {
                 $n_firme['gruppo'] += $row['nf'];
             }
         } else {
             if (count($schier_pres) > 0 && $row['maggioranza'] == $schier_pres[0]) {
                 $n_firme['altri'] += $row['nf'];
             } else {
                 $n_firme['gruppo'] += $row['nf'];
             }
         }
     }
     $d_punteggio = 0.0;
     foreach ($n_firme as $tipo => $value) {
         if (!$value) {
             continue;
         }
         $soglia = self::$soglia_cofirme;
         if ($tipo_atto == 'mozione') {
             $soglia = self::$soglia_cofirme_mozioni;
         }
         if ($value <= $soglia) {
             $d_punteggio += $dd_punteggio = self::getPunteggio($tipo_atto, "cofirme_{$tipo}_lo", $di_maggioranza);
         } else {
             $d_punteggio += $dd_punteggio = self::getPunteggio($tipo_atto, "cofirme_{$tipo}_hi", $di_maggioranza);
         }
         $firme_node = $consenso_node->addChild('firme_' . $tipo, null, self::$opp_ns);
         $firme_node->addAttribute('n_firme', $value);
         $firme_node->addAttribute('totale', $dd_punteggio);
         if ($verbose) {
             printf("    firme %s (%d) %7.2f\n", $tipo, $value, $dd_punteggio);
         }
     }
     $punteggio += $d_punteggio;
     if ($verbose) {
         printf("  totale firme  %7.2f\n", $d_punteggio);
     }
     $consenso_node->addAttribute('n_firme', $n_firme['gruppo'] + $n_firme['altri'] + $n_firme['opp']);
     $consenso_node->addAttribute('totale', $d_punteggio);
     // --- iter ---
     // controlla se atti non assorbiti sono diventati legge dopo passaggi in altri rami
     // atti diventati legge non prendono il punteggio di approvazione
     $diventato_legge_in_altri_rami = false;
     if (!isset($passaggio) || $passaggio != 'assorbito') {
         $atto = OppAttoPeer::retrieveByPK($atto_id);
         $c = new Criteria();
         $c->add(OppAttoHasIterPeer::ITER_ID, 16);
         $c->add(OppAttoHasIterPeer::DATA, $data, Criteria::LESS_EQUAL);
         while ($atto_succ_id = $atto->getSucc()) {
             $atto = OppAttoPeer::retrieveByPK($atto_succ_id);
             if ($atto->countOppAttoHasIters($c) > 0) {
                 $diventato_legge_in_altri_rami = true;
             }
         }
         unset($c);
         unset($atto);
     }
     // determina se l'atto è parte di un Testo Unificato
     $is_unified = OppAttoPeer::isUnifiedText($atto_id);
     // determina se l'atto è stato assorbito
     $is_absorbed = OppAttoPeer::isAbsorbed($atto_id);
     // determina se l'atto unificato è principale o meno
     $is_unificato_non_main = is_array($is_unified) && !$is_unified['is_main_unified'];
     $is_unificato_main = is_array($is_unified) && $is_unified['is_main_unified'];
     $itinera_atto_rs = OppAttoHasIterPeer::getItineraAttoDataRS($atto_id, $data);
     $iter_node = $atto_node->addChild('iter', null, self::$opp_ns);
     $d_punteggio = 0.0;
     $n_passaggi = 0;
     while ($itinera_atto_rs->next()) {
         $iter_atto = $itinera_atto_rs->getRow();
         $passaggio = OppIterPeer::getIterPerIndice($iter_atto['iter_id']);
         if (is_null($passaggio)) {
             continue;
         }
         // se l'atto è unificato e non-main, allora prende il punteggio come gli atti assorbiti
         if ($is_unificato_non_main && $passaggio == 'approvato') {
             $passaggio = 'assorbito';
         }
         // se diventato legge in altri rami, non prende punteggio di approvazione
         if ($diventato_legge_in_altri_rami && $passaggio == 'approvato') {
             continue;
         }
         $n_passaggi++;
         $passaggio_node = $iter_node->addChild('passaggio', null, self::$opp_ns);
         if ($passaggio == 'assorbito' && $is_unificato_non_main) {
             $passaggio_node->addAttribute('tipo', 'assorbimento come unificato non principale');
         } else {
             $passaggio_node->addAttribute('tipo', $passaggio);
         }
         $d_punteggio += $dd_punteggio = self::getPunteggio($tipo_atto, $passaggio, $di_maggioranza);
         if ($verbose) {
             if ($passaggio == 'assorbito' && $is_unificato_non_main) {
                 printf("    iter %s %7.2f\n", 'assorbimento come unificato non principale', $dd_punteggio);
             } else {
                 printf("    iter %s %7.2f\n", $passaggio, $dd_punteggio);
             }
         }
         $passaggio_node->addAttribute('totale', $dd_punteggio);
         // il break su atti assorbiti avviene dopo l'assegnazione del punteggio
         if ($passaggio == 'assorbito') {
             break;
         }
         // --- bonus maggioranza ---
         if ($passaggio == 'approvato') {
             if ($di_maggioranza && OppAttoPeer::isAttoVotatoDaOpposizione($atto_id, $data)) {
                 $d_punteggio += $dd_punteggio = self::getPunteggio($tipo_atto, 'bonus_bi_partisan', true);
                 $bonus_node = $iter_node->addChild('bonus_maggioranza', null, self::$opp_ns);
                 $bonus_node->addAttribute('totale', $dd_punteggio);
                 if ($verbose) {
                     printf("    bonus di maggioranza! %7.2f\n", $dd_punteggio);
                 }
             }
         }
         // break se mozione, risoluzione o odg approvato
         if (in_array($tipo_atto, array('mozione', 'risoluzione', 'odg')) && $passaggio == 'approvato') {
             break;
         }
     }
     // assegna punteggio se diventato legge in altri rami
     if ($diventato_legge_in_altri_rami && is_null($is_absorbed) && (is_null($is_unified) || $is_unificato_main)) {
         $d_punteggio += $dd_punteggio = self::getPunteggio($tipo_atto, 'diventato_legge', $di_maggioranza);
         $passaggio_node = $iter_node->addChild('passaggio', null, self::$opp_ns);
         $passaggio_node->addAttribute('tipo', "diventato legge in altri rami");
         $passaggio_node->addAttribute('totale', $dd_punteggio);
         if ($verbose) {
             printf("    iter %s %7.2f\n", "diventato legge in altri rami", $dd_punteggio);
         }
     }
     $punteggio += $d_punteggio;
     if ($verbose) {
         printf("  totale iter   %7.2f\n", $d_punteggio);
     }
     $iter_node->addAttribute('n_passaggi', $n_passaggi);
     $iter_node->addAttribute('totale', $d_punteggio);
     // --- componente emendamenti con funzione sigmoide ---
     $punteggio += $d_punteggio = self::calcolaComponenteEmendamentiPerAtto($atto_id, $data, $atto_node, $verbose);
     // --- sedute con interventi in commissione e assemblea ---
     $sedute_con_interventi_node = $atto_node->addChild('sedute_con_interventi', null, self::$opp_ns);
     $sedute_commissioni_node = $sedute_con_interventi_node->addChild('commissioni', null, self::$opp_ns);
     $n_sedute_commissioni = OppInterventoPeer::getNSeduteConInterventiAttoData($atto_id, 'C', $data);
     if ($n_sedute_commissioni) {
         $n_sedute_commissioni--;
     }
     if ($verbose) {
         printf("    n. sedute in commissione   %d\n", $n_sedute_commissioni);
     }
     $d_punteggio_sedute_commissioni = $n_sedute_commissioni * parent::$punteggi['seduta_in_comm'];
     $sedute_commissioni_node->addAttribute('n_sedute', $n_sedute_commissioni);
     $sedute_commissioni_node->addAttribute('totale', $d_punteggio_sedute_commissioni);
     $sedute_assemblea_node = $sedute_con_interventi_node->addChild('assemblea', null, self::$opp_ns);
     $n_sedute_assemblea = OppInterventoPeer::getNSeduteConInterventiAttoData($atto_id, 'A', $data);
     if ($n_sedute_assemblea) {
         $n_sedute_assemblea--;
     }
     if ($verbose) {
         printf("    n. sedute in commissione   %d\n", $n_sedute_assemblea);
     }
     $d_punteggio_sedute_assemblea = $n_sedute_assemblea * parent::$punteggi['seduta_in_ass'];
     $sedute_assemblea_node->addAttribute('n_sedute', $n_sedute_assemblea);
     $sedute_assemblea_node->addAttribute('totale', $d_punteggio_sedute_assemblea);
     $punteggio += $d_punteggio_sedute = $d_punteggio_sedute_commissioni + $d_punteggio_sedute_assemblea;
     if ($verbose) {
         printf("  totale sedute   %7.2f\n", $d_punteggio_sedute);
     }
     $sedute_con_interventi_node->addAttribute('totale', $d_punteggio_sedute);
     if ($atto_is_ratifica) {
         $atto_node->addAttribute('totale_pre_decurtazione_ratifica', $punteggio);
         if ($verbose) {
             print "questo ATTO è una ratifica\n";
         }
         $punteggio = $punteggio / self::$punteggi['fattore_diminuzione_ratifica'];
     }
     $punteggio = $priorita * $punteggio;
     $atto_node->addAttribute('totale', $punteggio);
     return $punteggio;
 }