package com.whyc.factory;

public class BattCapFactory {
	public static int  CapType_Rest = 0;			//当查询剩余容量时传递
	public static int  CapType_Real = 1;			//当查询实际容量时传递
	
	public static int  CapType_type=2;       //容量
	public static int  CapType_name=1;       //次低
	public static int  CapType_method=0;     //标称
	// 获取标纯电流
	public static double GetFDCurrent(double stdcap, int hourrate)
	{
		double res = 0.055;
	    switch(hourrate)
	    {
	        case 1: res = 0.514; break;
	        case 2: res = 0.306; break;
	        case 3: res = 0.250; break;
	        case 4: res = 0.200; break;
	        case 5: res = 0.166; break;
	        case 6: res = 0.146; break;
	        case 7: res = 0.131; break;
	        case 8: res = 0.118; break;
	        case 9: res = 0.108; break;
	        case 10: res = 0.100; break;
	        case 20: res = 0.055; break;
	        default: res = 0.055; break;
	    }
	    
	    return (stdcap * res);
	}
	//------------------------------------------------------------------------------
	//------------------------------------------------------------------------------
	// 获取放电小时率		stdah：标纯容量          current:当前电流
	public static int GetHourRate(double stdah, double current)
	{
		int index = 0;
		double value[]={5.14, 3.06, 2.50, 2.00, 1.66, 1.46, 1.31, 1.18, 1.08, 1.00, 0.55, 0.40};
	    double res;
	    current = Math.abs(current);
		res = current/(stdah/10);
	    if(res >= 5.14) return 1;
	    else if(res <= 0.55) return 20;
	    else
	    {
			for(index=0; index<10; index++)
	        {
				if((res<=value[index]) && (res>value[index+1]))
					break;
	            else continue;
	        }
	        if((value[index]-res) < (res-value[index+1]))
	        {
				return (index+1);
	        }
			else
	        {
				if(index+2 > 10) return (20);
				else return (index+2);
	        }
	    }  
	}
	//------------------------------------------------------------------------------
	//------------------------------------------------------------------------------
	public static double N_TO_10H(int n_H)
	{
	    switch(n_H)
	    {
	        case  1 : return(1/0.55);
	        case  2 : return(1/0.61);
	        case  3 : return(1/0.75);
	        case  4 : return(1/0.79);
	        case  5 : return(1/0.833);
	        case  6 : return(1/0.876);
	        case  7 : return(1/0.917);
	        case  8 : return(1/0.944);
	        case  9 : return(1/0.974);
	        case  10: return(1/1);
	        case  20: return(1/1.1);
	    }
	    return 1.0;
	}
	//-------------------------------------------------------------------------------
	//-------------------------------------------------------------------------------
	//获取剩余容量	STDAH：标称容量		HourRate：放电小时率	SumAH：测试容量		MaxMonomerVol：最大电池电压		MonomerVol：当前电池组的最低单体电压
	//MonomerVolType:电池电压类型 电池标称电压	2v,6v,12v	CapType:容量类型（定值是常量）
	
	                                                     //小时率		已测试容量			最容量
	public static double GetMonomerCap(double STDAH, int HourRate, double SumAH, double MaxMonomerVol,
																
	                    				double MonomerVol, double MonomerVolType, int CapType)
	{
		if((MaxMonomerVol - MonomerVolType*0.9) <= 0)
	        return 0;

	    if(SumAH < 0)
	        SumAH *= (-1);

	    double tmp_cap;
	    tmp_cap = MonomerVol - MonomerVolType * 0.9;
	    tmp_cap *= (STDAH - SumAH * N_TO_10H(HourRate));
	    double dt_vol = MaxMonomerVol - MonomerVolType*0.9;
	    if(dt_vol < 0.01)
	    	dt_vol = 0.01;
	    tmp_cap = tmp_cap/dt_vol;
	    if(tmp_cap < 0)
	        tmp_cap = 0;

	    if(CapType == CapType_Rest)
	        return tmp_cap;
	    else if(CapType == CapType_Real)
	        return (tmp_cap + SumAH * N_TO_10H(HourRate));
	    else
	        return ((tmp_cap + SumAH * N_TO_10H(HourRate))*100 / STDAH);
	}
	//----------------------------------------------------------------------------------
	//----------------------------------------------------------------------------------
	//获取后备时间
	public static int GetRestTimeSecond(double restcap, double curr)
	{
		double tmp_curr = Math.abs(curr);
		if(tmp_curr < 0.1)
			tmp_curr = 0.1;
			
		int rest_time = (int)((restcap / tmp_curr) * 3600);
		if(rest_time > (99*3600))
			rest_time = (99*3600);
			
		return rest_time;
	}
	/*//判断通过实际容量判断某次放电测试是否有效
	*//*
	 * STDAH:标存容量
	 * param:容量有效参数*//*
	public static  int Judge(double realCap,float param,double STDAH){
		int flag=0;
		if(Math.abs(realCap)>(param*STDAH)){
			flag=1;
		}else{
			flag=0;
		}
		return flag;
		}
	//判断通过实际容量判断某次放电测试是否有效
		*//*
		 * STDAH:标存容量
		 * param:容量告警参数*//*
	public static  int JudgeAlarm(double realCap,float param,float Cparam,double STDAH){
		int flag=0;
		if(realCap>(param*STDAH)){
			flag=1;
		}else{
			if(realCap<(Cparam*STDAH)){
				flag=AlarmDaoFactory.Alarm_CapChange;
			}else{
				flag=AlarmDaoFactory.Alarm_CapAlarm;
			}
			
		}
		return flag;
 	}*/

	/**
	 * 电池组的续航时长计算,单位:分钟
	 */
	public static float getTheoryTime(float loadCurr, float restcap, float battGroupCapStd){
		double realCurr = 53*loadCurr/45;
		double hourRate = N_TO_10H(GetHourRate((int) Math.floor(battGroupCapStd), realCurr));
		float theoryTimeHour = realCurr == 0?0: (float) (restcap / hourRate / realCurr);
		return theoryTimeHour*60;
	}
}