"""

def __init__(self, axis_tilt=0, axis_azimuth=0, max_angle=90,

backtrack=True, gcr=2.0/7.0, cross_axis_tilt=0.0, **kwargs):

self.axis_tilt = axis_tilt

self.axis_azimuth = axis_azimuth

self.max_angle = max_angle

self.backtrack = backtrack

self.gcr = gcr

self.cross_axis_tilt = cross_axis_tilt

kwargs['surface_tilt'] = None

kwargs['surface_azimuth'] = None

super().__init__(**kwargs)

def __repr__(self):

attrs = ['axis_tilt', 'axis_azimuth', 'max_angle', 'backtrack', 'gcr',

'cross_axis_tilt']

sat_repr = ('SingleAxisTracker:\n ' + '\n '.join(

f'{attr}: {getattr(self, attr)}' for attr in attrs))

# get the parent PVSystem info

pvsystem_repr = super().__repr__()

# remove the first line (contains 'PVSystem: \n')

pvsystem_repr = '\n'.join(pvsystem_repr.split('\n')[1:])

return sat_repr + '\n' + pvsystem_repr

def singleaxis(self, apparent_zenith, apparent_azimuth):

"""

tracking_data = singleaxis(apparent_zenith, apparent_azimuth,

self.axis_tilt, self.axis_azimuth,

self.max_angle, self.backtrack,

self.gcr, self.cross_axis_tilt)

return tracking_data

@deprecated('0.8',

def localize(self, location=None, latitude=None, longitude=None,

**kwargs):

"""

if location is None:

location = Location(latitude, longitude, **kwargs)

return LocalizedSingleAxisTracker(pvsystem=self, location=location)

def get_aoi(self, surface_tilt, surface_azimuth, solar_zenith,

solar_azimuth):

"""Get the angle of incidence on the system.

aoi = irradiance.aoi(surface_tilt, surface_azimuth,

solar_zenith, solar_azimuth)

return aoi

def get_irradiance(self, surface_tilt, surface_azimuth,

solar_zenith, solar_azimuth, dni, ghi, dhi,

dni_extra=None, airmass=None, model='haydavies',

**kwargs):

"""

# not needed for all models, but this is easier

if dni_extra is None:

dni_extra = irradiance.get_extra_radiation(solar_zenith.index)

if airmass is None:

airmass = atmosphere.get_relative_airmass(solar_zenith)

return irradiance.get_total_irradiance(surface_tilt,

surface_azimuth,

solar_zenith,

solar_azimuth,

dni, ghi, dhi,

dni_extra=dni_extra,

airmass=airmass,

model=model,

albedo=self.albedo,

"""

def __init__(self, pvsystem=None, location=None, **kwargs):

new_kwargs = _combine_localized_attributes(

pvsystem=pvsystem,

location=location,

**kwargs,

)

SingleAxisTracker.__init__(self, **new_kwargs)

Location.__init__(self, **new_kwargs)

def __repr__(self):

attrs = ['latitude', 'longitude', 'altitude', 'tz']

return ('Localized' +

super().__repr__() + '\n ' +

'\n '.join(

axis_tilt=0, axis_azimuth=0, max_angle=90,

backtrack=True, gcr=2.0/7.0, cross_axis_tilt=0):

"""

# MATLAB to Python conversion by

# Will Holmgren (@wholmgren), U. Arizona. March, 2015.

if isinstance(apparent_zenith, pd.Series):

index = apparent_zenith.index

else:

index = None

# convert scalars to arrays

apparent_azimuth = np.atleast_1d(apparent_azimuth)

apparent_zenith = np.atleast_1d(apparent_zenith)

if apparent_azimuth.ndim > 1 or apparent_zenith.ndim > 1:

raise ValueError('Input dimensions must not exceed 1')

# Calculate sun position x, y, z using coordinate system as in [1], Eq 1.

# NOTE: solar elevation = 90 - solar zenith, then use trig identities:

# sin(90-x) = cos(x) & cos(90-x) = sin(x)

sin_zenith = sind(apparent_zenith)

x = sin_zenith * sind(apparent_azimuth)

y = sin_zenith * cosd(apparent_azimuth)

z = cosd(apparent_zenith)

# Assume the tracker reference frame is right-handed. Positive y-axis is

# oriented along tracking axis; from north, the y-axis is rotated clockwise

# by the axis azimuth and tilted from horizontal by the axis tilt. The

# positive x-axis is 90 deg clockwise from the y-axis and parallel to

# horizontal (e.g., if the y-axis is south, the x-axis is west); the

# positive z-axis is normal to the x and y axes, pointed upward.

# Calculate sun position (xp, yp, zp) in tracker coordinate system using

# [1] Eq 4.

cos_axis_azimuth = cosd(axis_azimuth)

sin_axis_azimuth = sind(axis_azimuth)

cos_axis_tilt = cosd(axis_tilt)

sin_axis_tilt = sind(axis_tilt)

xp = x*cos_axis_azimuth - y*sin_axis_azimuth

yp = (x*cos_axis_tilt*sin_axis_azimuth

+ y*cos_axis_tilt*cos_axis_azimuth

- z*sin_axis_tilt)

zp = (x*sin_axis_tilt*sin_axis_azimuth

+ y*sin_axis_tilt*cos_axis_azimuth

+ z*cos_axis_tilt)

# The ideal tracking angle wid is the rotation to place the sun position

# vector (xp, yp, zp) in the (y, z) plane, which is normal to the panel and

# contains the axis of rotation. wid = 0 indicates that the panel is

# horizontal. Here, our convention is that a clockwise rotation is

# positive, to view rotation angles in the same frame of reference as

# azimuth. For example, for a system with tracking axis oriented south, a

# rotation toward the east is negative, and a rotation to the west is

# positive. This is a right-handed rotation around the tracker y-axis.

# Calculate angle from x-y plane to projection of sun vector onto x-z plane

# using [1] Eq. 5.

wid = np.degrees(np.arctan2(xp, zp))

# filter for sun above panel horizon

zen_gt_90 = apparent_zenith > 90

wid[zen_gt_90] = np.nan

# Account for backtracking

if backtrack:

# distance between rows in terms of rack lengths relative to cross-axis

# tilt

axes_distance = 1/(gcr * cosd(cross_axis_tilt))

# NOTE: account for rare angles below array, see GH 824

temp = np.abs(axes_distance * cosd(wid - cross_axis_tilt))

# backtrack angle using [1], Eq. 14

with np.errstate(invalid='ignore'):

wc = np.degrees(-np.sign(wid)*np.arccos(temp))

# NOTE: in the middle of the day, arccos(temp) is out of range because

# there's no row-to-row shade to avoid, & backtracking is unnecessary

# [1], Eqs. 15-16

with np.errstate(invalid='ignore'):

tracker_theta = wid + np.where(temp < 1, wc, 0)

else:

tracker_theta = wid

# NOTE: max_angle defined relative to zero-point rotation, not the

# system-plane normal

tracker_theta = np.clip(tracker_theta, -max_angle, max_angle)

# Calculate panel normal vector in panel-oriented x, y, z coordinates.

# y-axis is axis of tracker rotation. tracker_theta is a compass angle

# (clockwise is positive) rather than a trigonometric angle.

# NOTE: the *0 is a trick to preserve NaN values.

panel_norm = np.array([sind(tracker_theta),

tracker_theta*0,

cosd(tracker_theta)])

# sun position in vector format in panel-oriented x, y, z coordinates

sun_vec = np.array([xp, yp, zp])

# calculate angle-of-incidence on panel

aoi = np.degrees(np.arccos(np.abs(np.sum(sun_vec*panel_norm, axis=0))))

# Calculate panel tilt and azimuth in a coordinate system where the panel

# tilt is the angle from horizontal, and the panel azimuth is the compass

# angle (clockwise from north) to the projection of the panel's normal to

# the earth's surface. These outputs are provided for convenience and

# comparison with other PV software which use these angle conventions.

# Project normal vector to earth surface. First rotate about x-axis by

# angle -axis_tilt so that y-axis is also parallel to earth surface, then

# project.

# Calculate standard rotation matrix

rot_x = np.array([[1, 0, 0],

[0, cosd(-axis_tilt), -sind(-axis_tilt)],

[0, sind(-axis_tilt), cosd(-axis_tilt)]])

# panel_norm_earth contains the normal vector expressed in earth-surface

# coordinates (z normal to surface, y aligned with tracker axis parallel to

# earth)

panel_norm_earth = np.dot(rot_x, panel_norm).T

# projection to plane tangent to earth surface, in earth surface

# coordinates

projected_normal = np.array([panel_norm_earth[:, 0],

panel_norm_earth[:, 1],

panel_norm_earth[:, 2]*0]).T

# calculate vector magnitudes

projected_normal_mag = np.sqrt(np.nansum(projected_normal**2, axis=1))

# renormalize the projected vector, avoid creating nan values.

non_zeros = projected_normal_mag != 0

projected_normal[non_zeros] = (projected_normal[non_zeros].T /

projected_normal_mag[non_zeros]).T

# calculation of surface_azimuth

surface_azimuth = \

np.degrees(np.arctan2(projected_normal[:, 1], projected_normal[:, 0]))

# Rotate 0 reference from panel's x-axis to its y-axis and then back to

# north.

surface_azimuth = 90 - surface_azimuth + axis_azimuth

# Map azimuth into [0,360) domain.

with np.errstate(invalid='ignore'):

surface_azimuth = surface_azimuth % 360

# Calculate surface_tilt

dotproduct = (panel_norm_earth * projected_normal).sum(axis=1)

surface_tilt = 90 - np.degrees(np.arccos(dotproduct))

# Bundle DataFrame for return values and filter for sun below horizon.

out = {'tracker_theta': tracker_theta, 'aoi': aoi,

'surface_tilt': surface_tilt, 'surface_azimuth': surface_azimuth}

if index is not None:

out = pd.DataFrame(out, index=index)

out = out[['tracker_theta', 'aoi', 'surface_azimuth', 'surface_tilt']]

out[zen_gt_90] = np.nan

else:

out = {k: np.where(zen_gt_90, np.nan, v) for k, v in out.items()}

"""

delta_gamma = axis_azimuth - slope_azimuth

# equations 18-19

tan_axis_tilt = cosd(delta_gamma) * tand(slope_tilt)

"""

cos_ba = cosd(ba)

cos_bg = cosd(bg)

sin_bg = sind(bg)

sin_dg = sind(dg)

vx = sin_dg * cos_ba * cos_bg

vy = sind(ba)*sin_bg + cosd(dg)*cos_ba*cos_bg

vz = -sin_dg*sin_bg*cos_ba

"""

vnorm = np.sqrt(np.dot(v, v))

beta_c = np.arcsin(

((v[0]*cosd(dg) - v[1]*sind(dg)) * sind(ba) + v[2]*cosd(ba)) / vnorm)

slope_azimuth, slope_tilt, axis_azimuth, axis_tilt):

"""

# delta-gamma, difference between axis and slope azimuths

delta_gamma = axis_azimuth - slope_azimuth

# equation 22

v = _calc_tracker_norm(axis_tilt, slope_tilt, delta_gamma)

# equation 26

beta_c = _calc_beta_c(v, delta_gamma, axis_tilt)