List of Class Instances Creating Null Pointer Exception,List of Class Instances Creates a Null Object

Hi! So I was working on a project where I need to declare a List of class objects (called basisFields) as a member variable to the class I'm using, and when I try to implement it, I receive a NullReferenceException when the AddField is called, and the print statement at the end of the code isn't written. Does anyone happen to know a fix to t$$anonymous$$s? I'd prefer to keep the MonoBehavior extension if possible since I have several dependencies on its use!

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using SimplexNoise;
 using System;
 
 public struct NoiseParams
 {
     public bool globalNoise;
     public float noiseSizePark;
     public float noiseAnglePark; // in degrees
     public float noiseSizeGlobal;
     public float noiseAngleGlobal;
 };
 
 // Combines basis fields
 // Noise added when sampling a point in a given parks
 public class TensorField : MonoBehaviour
 {
     // global vars
     private List<BasisField> basisFields = new List<BasisField>();
     public Noise noise;
     private NoiseParams nParams;
 
     public List<List<Vector2>> parks = new List<List<Vector2>>();
     public List<Vector2> sea = new List<Vector2>();
     public List<Vector2> river = new List<Vector2>();
     public bool ignoreRiver = false;
 
     public bool smooth = false;
 
     public TensorField(NoiseParams noiseParams)
     {
         t$$anonymous$$s.nParams = noiseParams;
     }
 
     // used to integrate coastline and river
     public void enableGlobalNoise(float angle, float size)
     {
         t$$anonymous$$s.nParams.globalNoise = true;
         t$$anonymous$$s.nParams.noiseAngleGlobal = angle;
         t$$anonymous$$s.nParams.noiseSizeGlobal = size;
     }
 
     public void disableGlobalNoise()
     {
         t$$anonymous$$s.nParams.globalNoise = false;
     }
 
     public void addGrid(Vector2 center, int size, float decay, float theta)
     {
         Grid grid = gameObject.AddComponent<Grid>();
         grid._center = center;
         grid._size = size;
         grid._decay = decay;
         grid._theta = theta;
         t$$anonymous$$s.addField(grid);
         Debug.Log("Field was added");
     }
 
     public void addRadial(Vector2 center, int size, float decay)
     {
         Radial radial = new Radial(center, size, decay);
         t$$anonymous$$s.addField(radial);
     }
 
     protected void addField(BasisField basisField)
     {
         Debug.Log(basisField);
         t$$anonymous$$s.basisFields.Add(basisField);
         Debug.Log("Field Added");
     }
 
     protected void removeField(BasisField basisField)
     {
         int index = t$$anonymous$$s.basisFields.IndexOf(basisField);
         if (index > -1)
             t$$anonymous$$s.basisFields.RemoveAt(index);
     }
 
     private void Reset()
     {
         t$$anonymous$$s.basisFields = new List<BasisField>();
         t$$anonymous$$s.parks = new List<List<Vector2>>();
         t$$anonymous$$s.sea = new List<Vector2>();
         t$$anonymous$$s.river = new List<Vector2>();
     }
 
     public List<Vector2> getCenterPoints()
     {
         List<Vector2> centerPoints = new List<Vector2>();
         foreach (BasisField b in t$$anonymous$$s.basisFields)
         {
             centerPoints.Add(b._center);
         }
 
         return centerPoints;
     }
 
     public List<BasisField> getBasisFields()
     {
         return t$$anonymous$$s.basisFields;
     }
 
     public Tensor samplePoint(Vector2 point)
     {
         if (!t$$anonymous$$s.onLand(point))
         {
             // degenerate point
             return Tensor.zero();
         }
 
         // default field is a grid
         if (t$$anonymous$$s.basisFields.Count == 0)
         {
             float[] arr = { 0, 0 };
             return new Tensor(1, arr);
         }
 
         Tensor tensorAcc = Tensor.zero();
 
         t$$anonymous$$s.basisFields.ForEach(field => tensorAcc.add(field.getWeightedTensor(point, t$$anonymous$$s.smooth), t$$anonymous$$s.smooth));
 
         // add rotational noise for parks, range of -pi/2 to pi/2
         if (t$$anonymous$$s.parks.Exists(p => PolygonUtil.insidePolygon(point, p)))
         {
             tensorAcc.rotate(getRotationalNoise(point, t$$anonymous$$s.nParams.noiseSizePark, t$$anonymous$$s.nParams.noiseAnglePark));
         }
 
         if (t$$anonymous$$s.nParams.globalNoise)
         {
             tensorAcc.rotate(getRotationalNoise(point, t$$anonymous$$s.nParams.noiseSizeGlobal, t$$anonymous$$s.nParams.noiseAngleGlobal));
         }
 
         return tensorAcc;
 
     }
 
     private float getRotationalNoise(Vector2 point, float noiseSize, float noiseAngle)
     {
         return t$$anonymous$$s.noise.CalcPixel2D((int)point.x, (int)point.y, noiseSize) * noiseAngle * Mathf.PI / 180;
     }
 
     public bool onLand(Vector2 point)
     {
        bool inSea = PolygonUtil.insidePolygon(point, t$$anonymous$$s.sea);
         if (t$$anonymous$$s.ignoreRiver)
         {
             return !inSea;
         }
 
         return !inSea && !PolygonUtil.insidePolygon(point, t$$anonymous$$s.river);
     }
 
     public bool inParks(Vector2 point)
     {
         foreach (List<Vector2> park in parks)
         {
             if (PolygonUtil.insidePolygon(point, park))
                 return true;
         }
 
         return false;
     }
 }