/**
* Permite hacer el cálculo del Modelo de Costos por Servicio. Tomando
* la información que fue previamente caracterizada.
*
* Nota: Por servicio en conjunto con el mes debe existir una única caracterización asociada.
* De manera que ésta debería de correrse mensualmente.
*
* Creado: 14-Sep-2014
* @param Integer $year Año
* @param Integer $month Mes, Por defecto está configurada la opción NA la cual
* indica que se calculará el modelo para el año completo si existe data de
* caracterización, de lo contrario
* será un número que indica el mes al cual se le va a calcular el Modelo.
* @return
*/
public function modelo_costos($year, $month="NA"){
$debug = false;
//Calculando la estructura de costos para el año seleccionado
//Internamente se agregan las fechas de caducidad a cada uno de los componentes de TI.
$this->costos_model->estructura_costos_by_year_all($year);
$sql = "SELECT servicio_id, total_uso_redes, total_uso_cpu,
total_uso_almacenamiento, total_uso_memoria,
YEAR(fecha) anio , MONTH(fecha) mes, ec.estructura_costo_id, ec.fecha_creacion as fecha_ec
FROM caracterizacion AS c
JOIN estructura_costo ec ON year(c.fecha) = ec.anio and month(c.fecha) = ec.mes
WHERE YEAR(c.fecha) = $year AND c.borrado = false
";
//Condición agregada el 04-Oct-2014
if($month != "NA"){//se agrega la condición para un mes en específico
$sql .= " AND MONTH(c.fecha) = $month ";
}
$query = $this->db->query($sql);
if($query->num_rows() > 0 ){
$rs = $query->result_array();
//Buscando los costos asociados a cada categoría y si ya fueron obtenidos
//no se buscan de nuevo
$ec = array();// estructura de costos
$sql_eci = "SELECT eci.*, c.nombre AS nom_categ
FROM estructura_costo_item eci
JOIN ma_categoria c ON c.ma_categoria_id = eci.ma_categoria_id
WHERE estructura_costo_id = ? ";
/**
* Permite guardar los costos por servicio
* que posteriormente serán almacenados en la tabla de
* 'servicio_costo'.
*
* @var array
*/
$costos_by_servicio = array();
//info de caracterización
foreach ($rs as $row) {
$ec_id = $row['estructura_costo_id'];
if($debug){
echo " ec_id $ec_id <br>";
}
if( !isset($ec[$ec_id]) ){
$q_eci = $this->db->query($sql_eci, array($ec_id) );
//info de la estructura de costos
$tmp_costos = array();
$rs_eci = $q_eci->result_array();
foreach ($rs_eci as $row_ci) {
$total_dinero = $row_ci['total_monetario'] + $row_ci['total_monetario_cost_ind'];
$dinero_por_unidad = $total_dinero/$row_ci['total_capacidad'];//Monto de dinero por unidad
$tmp_costos[$row_ci['nom_categ']]['dinero_por_uni'] = $dinero_por_unidad;
$tmp_costos[$row_ci['nom_categ']]['total_capacidad_porc'] = $row_ci['total_capacidad']/100;
}//end of: foreach inner
$ec[$ec_id] = $tmp_costos;
}
$rs_eci = $ec[$ec_id];//info de costos por unidad
$alm = $row['total_uso_almacenamiento'] * $rs_eci['Almacenamiento']['dinero_por_uni'];//está en bytes
$mem = ($row['total_uso_memoria'] * $rs_eci['Memoria']['total_capacidad_porc']) * $rs_eci['Memoria']['dinero_por_uni'];//está en %
//Temporalmente no se toma en cuenta el campo de redes
if(isset($rs_eci['Redes'])){
$red = $row['total_uso_redes'] * $rs_eci['Redes']['dinero_por_uni'];// NA
}else{
$red = 0;
}
//Fin de campo de redes
$proc = ($row['total_uso_cpu'] * $rs_eci['Procesador']['total_capacidad_porc']) * $rs_eci['Procesador']['dinero_por_uni'];//está en %
$costos_by_servicio[$row['servicio_id']] = array(
'almacenamiento'=>$alm,
'memoria'=>$mem,
'redes'=>$red,
'procesador'=>$proc,
'mes' =>$row['mes'],
'anio'=>$row['anio']
);
}//end of: foreach outter
if($debug){
echo_pre($costos_by_servicio); //prueba
}
//Inserción en la BD.
foreach ($costos_by_servicio as $servicio_id => $row) {
//Si ya existe un costo calculado para un mes y año se marca como
//borrado y se calcula de nuevo
$this->utilities_model->update_ar(
"servicio_costo",
array('borrado'=>TRUE),
array('mes'=>$row['mes'], 'anio'=>$row['anio'], 'servicio_id'=>$servicio_id)
);
//insertando fila en "servicio_costo"
$f = date('Y-m-d H:i:s',now());//fecha formato datetime
$total_costo = $row["almacenamiento"]+$row["memoria"]+$row["redes"]
+$row["procesador"];
$this->utilities_model->add_ar(
array(
"servicio_id"=>$servicio_id,
"costo"=>$total_costo,
"fecha_creacion"=>$f,
"mes"=>$row["mes"],
"anio"=>$row["anio"]
),
"servicio_costo"
);
$last_id_serv_cos = $this->utilities_model->last_insert_id();
//insertando servicio costo detalle
$f = date('Y-m-d H:i:s',now());//fecha formato datetime
$this->utilities_model->add_ar(
array(
"servicio_costo_id"=>$last_id_serv_cos,
"c_almacenamiento"=>$row["almacenamiento"],
"c_memoria"=>$row["memoria"],
"c_redes"=>$row["redes"],
"c_procesador"=>$row["procesador"]
),
"servicio_costo_detalle"
);
}
}// end of: if
}
public function testKmeans()
{
echo 'Inicio de kmeans<br>';
//1.- Obtencion de la data Solo Procesador
$dateArray = $this->dateLastMonth(0,1);
$dataBeforeKmeans = $this->capacity->resourceUseByComponent($dateArray,"tasa_cpu,comando_ejecutable,timestamp",FALSE);
$num_clusters = 6;
foreach ($dataBeforeKmeans as $beforekmeans)
{
$kmeansArrayCounter=0;
foreach ($beforekmeans as $key => $kmeans)
{
$beforekmeans[$kmeansArrayCounter][0]=$kmeans['tasa_cpu'];
$beforekmeans[$kmeansArrayCounter][1]=$kmeans['comando_ejecutable'];
$beforekmeans[$kmeansArrayCounter][2]=$kmeans['timestamp'];
unset($beforekmeans[$kmeansArrayCounter]['tasa_cpu']);
unset($beforekmeans[$kmeansArrayCounter]['comando_ejecutable']);
unset($beforekmeans[$kmeansArrayCounter]['timestamp']);
$kmeansArrayCounter++;
}
//2.- Correr el kmeans
$resultado = $this->kmeans->kmeans($beforekmeans,$num_clusters);
echo_pre($beforekmeans);
//echo_pre($resultado);// muestra todos los grupos y sus centroides
//pero se puede escoger un representadnte de cada grupo
}
//3.- Montrando los resultados definitivos escogiendo un representante de cada grupo
$rep = array();
foreach ($resultado['clusters'] as $cluster) {
$rep[] = $cluster[0]['coordenadas'];
}
//echo_pre($rep);
//4.- Con estos resultados se puede promediar.
echo 'Fin de kmeans<br>';
}
public function test(){
$date = modules::run('Capacidad/dateLastMonth',0,1);
$nom_procesos = $this->nom_proc_historial();
echo_pre($nom_procesos);
echo $nom_procesos[4] . "<br>";
$r = $this->proc_hist_por_hora_mensual($date,$nom_procesos[5],3);
echo_pre($r);
}
echo "entre<br>";
}
echo "Para ".$contadorComandos." ".$contadorHoras." Sumo ".$beforeGraficArray[0][$contadorHoras]." + ".$resource[$contadorComandos][$contadorHoras][0]."<br>";
$aux = $beforeGraficArray[0][$contadorHoras] + $resource[$contadorComandos][$contadorHoras][0];
$beforeGraficArray[0][$contadorHoras] = $aux;
echo "Resultado = ".$beforeGraficArray[0][$contadorHoras]."<br>";
$beforeGraficArray[1][$contadorHoras] = $beforeGraficArray[1][$contadorHoras] + $resource[$contadorComandos][$contadorHoras][1];
$beforeGraficArray[2][$contadorHoras] = $beforeGraficArray[2][$contadorHoras] + $resource[$contadorComandos][$contadorHoras][2];
$contadorHoras++;
}
$contadorComandos++;
}
$serviceId ++;
}
echo_pre($beforeGraficArray);
$resourceIndex = 0;
foreach ($resourceUse as $resource)
{
$biggerDate = 0;
?>
<script>
resourceUse[resourceIndex] = new Array();
var dataIndex = 0;
if(categorias.length < categoriasAux.length )
{
categorias = new Array();
categorias = categoriasAux;
resourceAux = categorias.length;
}
categoriasAux = new Array();
/**
* Permite la inicialización de los centroides.
* @param array $data Data para agrupar
* @param integer $k Número de clusters/centroides iniciales
* @return array Lista de centyroides.
*/
function inicializar_centroides(array $data, $k)
{
/**
* $dimensiones Guarda la longitud de cada entrada de la variable
* 'data'. Que para efectos de estudio del sistema de TI se trabajaría
* en R^2.
* @var array
*/
$dimensiones = count($data[0]);
$centroides = array();
$dimmax = array();
$dimmin = array();
foreach ($data as $coord) {
/**
* Buscando el máximo y el mínimo en cada entrada (x_i,y_i) de la data que será
* usado posteriormente para la inicialización propia de los
* centroides.
*
* Min (x_i, y_i)
* Max (x_j, y_j)
*
*/
foreach ($coord as $idx => $val) {
if (!isset($dimmax[$idx]) || $val > $dimmax[$idx]) {
//máximo
$dimmax[$idx] = $val;
}
if (!isset($dimmin[$idx]) || $val < $dimmin[$idx]) {
//mínimo
$dimmin[$idx] = $val;
}
}
}
if ($this->debug) {
echo "min ";
echo_pre($dimmin);
echo "max ";
echo_pre($dimmax);
}
for ($i = 0; $i < $k; $i++) {
$centroides[$i] = $this->inicializar_centroide($dimensiones, $dimmax, $dimmin);
}
return $centroides;
}
