Building business logic calculations that need data from parent objects

As a basic strategy, I would almost always avoid storing the same the same piece of information in two different places/classes of a data model, that leads too easily to unmaintainable code. If you start having attributes like numberOfMonths in two classes (like it was suggested in another answer), they can deviate from each other, you might have to write code to prevent this, have to care which is the "leading" version of that attribute, might have to duplicate documentation, and so on.

One solution you suggested was "A parent field so we can traverse back up the object to get the data". That is fine when in your business domain each PaidByItem object is related somehow to one Xyz and one Aaa object. Then it makes sense to express that relationship also in code by a reference:

public class PaidByItem {
    int feeAmount = 100;
    Xyz xyz; // lets assume this is Java or C#, so a reference, no copy!
    AAA aaa;

    // ...

    public double totalAmount (){
        return  feeAmount * xyz.numberOfMonths / aaa.daysPerYear;
    }
}

Non-sensical names like Xyz or Aaa, however, don't tell us much about the real domain. There can be lots of reasons why you do not want to introduce a dependency from Xyz or Aaa into PaidByItem. For example, they could lead to a cyclic dependency you need to avoid, or these kind of relationships/references simply don't make any sense from the domain point of view. For these cases, it is often be better to use your other suggestion "A separate calculation class to get the data, perform the calc and return a value". Or, you change the design to

    public double totalAmount (int numberOfMonths, int daysPerYear){
        return  feeAmount * numberOfMonths / daysPerYear;
    }

which means the caller of this method has the responsibility to make sure the totalAmount functions is called with the right parameters from the right objects. The last option makes most sense when those parameters like numberOfMonths are not required to come from a specific, referenced object.

TLDR: avoid redundant storage, pick the solution which represents your business domain most appropriately.

I don't know what language are you using so I will write in pseudocode.

There are many ways of achieving what you want. Some solutions require contained objects to know about theair containers. Some do not. The solutions that require contained objects know about their containers are more complex so I'll go with a solution that doesn't need contained objects to have access to the state of their containers.

I guess a chain of constructors could be a solution.

public class GrandParent {
    int daysPerYear = 360;
    Account someObject = new Account(daysPerYear);

}

public class Account {

    int percentageRate = 5;
    int numberOfMonths = 12;
    int daysPerYear;
    PaidByItem paidBy;

    public Account(int daysPerYear) {
        this.daysPerYear=daysPerYear;
        paidBy = new PaidByItem(numberOfMonths,daysPerYear);
    }   
}

public class PaidByItem {
    int feeAmount = 100;
    int daysPerYear;
    int numberOfMonths;

    public PaidByItem(int numberOfMonths, int daysPerYear) {
        this.numberOfMonths = numberOfMonths;
        this.daysPerYear=daysPerYear;
        System.out.println(this.totalAmount());
    }

    public double totalAmount (){
        return  feeAmount * numberOfMonths / daysPerYear;
    }
}

public class Test {
    public static void main(String args[]){
        GrandParent a = new GrandParent();
    }
}

Note: your formula doesn't take into account percentage rate so I guess it's wrong, and I don't like the original design approach but, I guess, as the names GrandParent, Account are fictitious and I don't really understand the reasons for doing that way, translated it as you have it.

In the test code as son as you instantiate GrandParent, the result is printed.