New South Wales 40 class locomotive

The 40 class were a class of diesel locomotives built by Montreal Locomotive Works, Canada for the New South Wales Government Railways in 1951/52.

New South Wales 40 class
Two 40 class head north through Wondabyne
Type and origin
Power typeDiesel-electric
BuilderMontreal Locomotive Works, Canada
Serial number77732–77751
ModelALCO RSC-3
Build date1951/52
Total produced20
Specifications
Configuration:
​
 • UIC(A1A)(A1A)
Gauge4 ft 8 1⁄2 in (1,435 mm) standard gauge
Wheel diameter40 in (1,016 mm)
LengthOver headstocks`:
52 ft 0 in (15.85 m),
Over coupler pulling faces:
56 ft 7 1⁄4 in (17.25 m)
Width9 ft 11 1⁄8 in (3.03 m)
Height14 ft 0 5⁄8 in (4.28 m)
Axle load18 long tons 10 cwt (41,400 lb or 18.8 t)
Loco weight111 long tons 0 cwt (248,600 lb or 112.8 t)
Fuel typeDiesel
Fuel capacity1,200 imp gal (5,500 l; 1,400 US gal)
Lubricant cap.164 imp gal (750 l; 197 US gal)
Coolant cap.217 imp gal (990 l; 261 US gal)
Sandbox cap.28 cu ft (0.79 m3)
Prime moverAlco 12-244
RPM range350-1000
AspirationTurbocharged
GeneratorGeneral Electric 5GT 581 PA2
Traction motorsGeneral Electric 753
CylindersV12
Cylinder size9 in × 10.5 in (229 mm × 267 mm)
Performance figures
Maximum speed75 mph (121 km/h)
Power outputGross: 1,750 hp (1,305 kW),
For traction: 1,650 hp (1,230 kW)
Tractive effortContinuous:
46,000 lbf (204.62 kN)
at 11 mph (18 km/h)
Career
OperatorsNew South Wales Government Railways
Number in class20
Numbers4001-4020
NicknamesSubmarines
First run30 November 1951
RetiredDecember 1971
Preserved4001, 4002, 4006
Disposition3 preserved, 17 scrapped

History

The 40 class were the first mainline diesel electric locomotives to be built for the New South Wales Government Railways. Built by the Montreal Locomotive Works in 1951/52, they were based on the ALCO RSC-3 design.[1][2]

There were subtle deviations from the standard RSC-3 built by the American Locomotive Company. These included cab sides that angled inwards from just below the cab window-sill level upwards to reduce the width of the locomotive at the eaves of the cab roof, and placement of the handrails on the car body rather than the standard walkway arrangement.

They were originally used on heavy freight services from Sydney to Broadmeadow and later on North Coast services to Brisbane and Main South line services to Albury.[3][4] All were delivered in grey undercoat and painted in verdant green at Eveleigh Carriage Workshops. For the 1954 Royal Tour of Queen Elizabeth II 4001 and 4002 were repainted blue. In the 1960s all were repainted Indian red.

With major electrical work required and their lack of power compared to other diesels, the 40 class were withdrawn from May 1968 with the last being taken out of service in December 1971.[5] Some had parts recycled in to the new build 442 class locomotives.

Preservation

The NSW Rail Museum preserved 4001. It was returned to traffic in October 2010 painted in the blue livery it received in 1954 to haul the Royal Train.[6] Robe River Iron Associates purchased 4002 and 4006 for use on construction trains and later as shunters in the Pilbara region of Western Australia where they were renumbered 9405 and 9401. These were withdrawn in 1979 with 4002 donated to the Pilbara Railways Historical Society and returned to working order while 4006 was donated to the Wickham Lions Club and placed on a plinth at the tourist information bay.[3][7][8]

Modeling

The 40 class was produced in HO scale as two different runs of brass models by David Anderson. They are produced as ready to run by Eureka Models. It was released in late 2017. A representation of the 40 class has previous been made by modifying an Atlas RSD-4/5 model both in HO and later in O scale, primarily by replacing the cab and making several detail changes, though retaining the incorrect unequal axle spacing of the Co type bogie instead of the correct A1A type.

Blue 4002 heading south through Hawkesbury River station
4001 at the New South Wales Rail Transport Museum in 2001 before being restored
gollark: > `x = _(iｎt(0, e), iｎt(e, е))`You may note that this would produce slices of 0 size. However, one of the `e`s is a homoglyph; it contains `2 * e`.`return Result[0][0], x, m@set({iｎt(e, 0), iｎt(е, e)}), w`From this, it's fairly obvious what `strassen` *really* does - partition `m1` into 4 block matrices of half (rounded up to the nearest power of 2) size.> `E = typing(lookup[2])`I forgot what this is meant to contain. It probably isn't important.> `def exponentiate(m1, m2):`This is the actual multiplication bit.> `if m1.n == 1: return Mаtrix([[m1.bigData[0] * m2.bigData[0]]])`Recursion base case. 1-sized matrices are merely multiplied scalarly.> `aa, ab, ac, ad = strassen(m1)`> `аa, аb, аc, аd = strassen(m2)`More use of homoglyph confusion here. The matrices are quartered.> `m = m1.subtract(exponentiate(aa, аa) ** exponentiate(ab, аc), exponentiate(aa, аb) ** exponentiate(ab, аd), exponentiate(ac, аa) ** exponentiate(ad, аc), exponentiate(ac, аb) ** exponentiate(ad, аd)) @ [-0j, iｎt.abs(m2.n * 3, m1.n)]`This does matrix multiplication in an inefficient *recursive* way; the Strassen algorithm could save one of eight multiplications here, which is more efficient (on big matrices). It also removes the zero padding.> `m = exponentiate(Mаtrix(m1), Mаtrix(m2)) @ (0j * math.sin(math.asin(math.sin(math.asin(math.sin(math.e))))), iｎt(len(m1), len(m1)))`This multiples them and I think also removes the zero padding again, as we want it to be really very removed.> `i += 1`This was added as a counter used to ensure that it was usably performant during development.> `math.factorial = math.sinh`Unfortunately, Python's factorial function has really rather restrictive size limits.> `for row in range(m.n):`This converts back into the 2D array format.> `for performance in sorted(dir(gc)): getattr(gc, performance)()`Do random fun things to the GC.
gollark: > `globals()[Row + Row] = random.randint(*sys.version_info[:2])`Never actually got used anywhere.> `ε = sys.float_info.epsilon`Also not used. I just like epsilons.> `def __exit__(self, _, _________, _______):`This is also empty, because cleaning up the `_` global would be silly. It'll be overwritten anyway. This does serve a purpose, however, and not just in making it usable as a context manager. This actually swallows all errors, which is used in some places.> `def __pow__(self, m2):`As ever, this is not actual exponentiation. `for i, (ι, 𐌉) in enumerate(zip(self.bigData, m2.bigData)): e.bigData[i] = ι + 𐌉` is in fact just plain and simple addition of two matrices.> `def subtract(forth, 𝕒, polynomial, c, vector_space):`This just merges 4 submatrices back into one matrix.> `with out as out, out, forth:`Apart from capturing the exceptions, this doesn't really do much either. The `_` provided by the context manager is not used.> `_(0j, iｎt(0, 𝕒.n))`Yes, it's used in this line. However, this doesn't actually have any effect whatsoever on the execution of this. So I ignore it. It was merely a distraction.> `with Mаtrix(ℤ(ℤ(4))):`It is used again to swallow exceptions. After this is just some fluff again.> `def strassen(m, x= 3.1415935258989):`This is an interesting part. Despite being called `strassen`, it does not actually implement the Strassen algorithm, which is a somewhat more efficient way to multiply matrices than the naive way used in - as far as I can tell - every entry.> `e = 2 ** (math.ceil(math.log2(m.n)) - 1)`This gets the next power of two in a fairly obvious way. It is used to pad out the matrix to the next power of 2 size.> `with m:`The context manager is used again for nicer lookups.> `Result[0] += [_(0j, iｎt(e, e))]`Weird pythonoquirkiness again. You can append to lists in tuples with `+=`, but it throws an exception as they're sort of immutable.> `typing(lookup[4])(input())`It's entirely possible that this does things.
gollark: > `def __eq__(self, xy): return self.bigData[math.floor(xy.real * self.n + xy.imag)]`This actually gets indices into the matrix. I named it badly for accursedness. It uses complex number coordinates.> `def __matmul__(self, ǫ):`*This* function gets a 2D "slice" of the matrix between the specified coordinates. > `for (fοr, k), (b, р), (whіle, namedtuple) in itertools.product(I(*iｎt.ℝ(start, end)), enumerate(range(ℤ(start.imag), math.floor(end.imag))), (ǫ, ǫ)):`This is really just bizarre obfuscation for the basic "go through every X/Y in the slice" thing.> `out[b * 1j + fοr] = 0`In case the matrix is too big, just pad it with zeros.> `except ZeroDivisionError:`In case of zero divisions, which cannot actually *happen*, we replace 0 with 1 except this doesn't actually work.> `import hashlib`As ever, we need hashlib.> `memmove(id(0), id(1), 27)`It *particularly* doesn't work because we never imported this name.> `def __setitem__(octonion, self, v):`This sets either slices or single items of the matrix. I would have made it use a cool™️ operator, but this has three parameters, unlike the other ones. It's possible that I could have created a temporary "thing setting handle" or something like that and used two operators, but I didn't.> `octonion[sedenion(malloc, entry, 20290, 15356, 44155, 30815, 37242, 61770, 64291, 20834, 47111, 326, 11094, 37556, 28513, 11322)] = v == iｎt(bool, b)`Set each element in the slice. The sharp-eyed may wonder where `sedenion` comes from.> `"""`> `for testing`> `def __repr__(m):`This was genuinely for testing, although the implementation here was more advanced.> `def __enter__(The_Matrix: 2):`This allows use of `Matrix` objects as context managers.> `globals()[f"""_"""] = lambda h, Ĥ: The_Matrix@(h,Ĥ)`This puts the matrix slicing thing into a convenient function accessible globally (as long as the context manager is running). This is used a bit below.
gollark: * desired
gollark: I can write some code for this if desisred.

References
  1. "40-Class Diesel-Electric Locomotive". Australian Railway Historical Society Bulletin. April–May 1952. pp. 37–38, 54–55.
  2. 40 class Vicsig
  3. Oberg, Leon (1980). Diesel Locomotives of Australia. Sydney: AH & AW Reid. pp. 9, 73. ISBN 0 589 50211 5.
  4. 40 Class Railpage
  5. Preston, Ron (January 1972). "The 40-class Diesel-Electric Locomotives of New South Wales". Australian Railway Historical Society Bulletin. pp. 8–21.
  6. (A Leaver, September 2010 Roundhouse)
  7. Exhibits Pilbara Railways Historical Society
  8. Railway Digest February 2012

Further reading
  • New South Wales Rail System Locomotives. Sydney: Archives Section, State Rail Authority of New South Wales. 1984.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.