private APointData calculatePointdata(double id, double iq, double speed)
{
double omega_e = speed / 60 * 2 * Math.PI * p;
double freq_e = speed / 60 * p;
APointData data = new APointData()
{
id = id,
iq = iq,
speed = speed,
torque = 1.5 * p * (psiM * iq + (Ld - Lq) * id * iq),
ed = -Lq * iq * omega_e,
eq = (psiM + Ld * id) * omega_e,
copperloss = 1.5 * R * (id * id + iq * iq),
rotorloss = rotor_Hloss_coeff * freq_e / 50 + rotor_Eloss_coeff * (freq_e / 50) * (freq_e / 50),
statorloss = stator_Hloss_coeff * freq_e / 50 + stator_Eloss_coeff * (freq_e / 50) * (freq_e / 50),
};
data.ud = R * id + data.ed;
data.uq = R * iq + data.eq;
return(data);
}
private EfficiencyMap buildEfficiencyMap(int torque_count, int speed_count, double Imax, double Umax, double max_speed)
{
MaxtorqueCapabilityCurve mtcc = buildMaxtorqueCapabilityCurve(speed_count, Imax, Umax, max_speed);
VoltageLimitCurve vlc = buildVoltageLimitCurve(speed_count, Imax, Umax, max_speed);
var em = new EfficiencyMap()
{
// input
Imax = Imax,
Umax = Umax,
MaxSpeed = max_speed,
// axis
speed_points = new double[speed_count + 1],
torque_points = new double[torque_count + 1],
// value
power = new double[speed_count + 1, torque_count + 1],
windingloss = new double[speed_count + 1, torque_count + 1],
rotor_coreloss = new double[speed_count + 1, torque_count + 1],
stator_coreloss = new double[speed_count + 1, torque_count + 1],
coreloss = new double[speed_count + 1, torque_count + 1],
totalloss = new double[speed_count + 1, torque_count + 1],
efficiency = new double[speed_count + 1, torque_count + 1],
voltage = new double[speed_count + 1, torque_count + 1],
current = new double[speed_count + 1, torque_count + 1],
beta = new double[speed_count + 1, torque_count + 1],
Ld = new double[speed_count + 1, torque_count + 1],
Lq = new double[speed_count + 1, torque_count + 1],
};
em.power.Fill2D(double.NaN);
em.windingloss.Fill2D(double.NaN);
em.rotor_coreloss.Fill2D(double.NaN);
em.stator_coreloss.Fill2D(double.NaN);
em.coreloss.Fill2D(double.NaN);
em.totalloss.Fill2D(double.NaN);
em.efficiency.Fill2D(double.NaN);
em.voltage.Fill2D(double.NaN);
em.current.Fill2D(double.NaN);
em.beta.Fill2D(double.NaN);
em.Ld.Fill2D(double.NaN);
em.Lq.Fill2D(double.NaN);
var mtpa = buildTableMaxtorquePerAmple();
double max_t = mtpa.GetMaxTorqueWithCurrentMagnitude(Imax);
LinearSpline torqueCapabilityLimit = LinearSpline.Interpolate(mtcc.speeds, mtcc.maxtorques);
for (int i = 0; i < speed_count + 1; i++)
{
for (int j = 0; j < torque_count + 1; j++)
{
// speed
double speed = max_speed * i / speed_count;
em.speed_points[i] = speed;
// torque
double t = max_t * j / torque_count;
em.torque_points[j] = t;
double max_possible_torque = torqueCapabilityLimit.Interpolate(speed);
if (t > max_possible_torque)
{
continue;
}
// speed limit 1
double speed1 = vlc.GetMaxSpeedForTorque(t);
APointData data = null;
if (t == 0)
{
data = calculatePointdata(0, 0, speed);
}
// zone 1
else if (speed <= speed1)
{
Fdq idq = mtpa.GetCurrentForTorque(t);
if (double.IsNaN(idq.d) || double.IsNaN(idq.q))
{
data = null;
}
else
{
data = calculatePointdata(idq.d, idq.q, speed);
}
}
else
{
Fdq idq = getCurrentForZone2(t, speed, Imax, Umax);
if (double.IsNaN(idq.d) || double.IsNaN(idq.q))
{
data = null;
}
else
{
data = calculatePointdata(idq.d, idq.q, speed);
}
}
if (data != null)
{
em.rotor_coreloss[i, j] = data.rotorloss;
em.stator_coreloss[i, j] = data.statorloss;
em.coreloss[i, j] = data.rotorloss + data.statorloss;
em.windingloss[i, j] = data.copperloss;
em.totalloss[i, j] = data.copperloss + data.rotorloss + data.statorloss;
em.power[i, j] = data.power;
em.efficiency[i, j] = 100 * data.power / (data.power + em.totalloss[i, j]);
em.voltage[i, j] = data.voltage;
em.current[i, j] = data.current;
em.beta[i, j] = data.beta;
em.Ld[i, j] = double.IsNaN(data.Ld) || data.Ld < 0 ? -0.0001 : data.Ld * 1000; //to mH
em.Lq[i, j] = double.IsNaN(data.Ld) || data.Ld < 0 ? -0.0001 : data.Lq * 1000; //to mH
}
}
}
return(em);
}
