// Class definition header file for derived classes FieldSyn (Field_2.h)
// Derived from Field
// FieldSyn has additional private member arrays
// to be initialised
//

#include <iostream>
#include <cstdlib>


using namespace std;

class Field
{
protected:
    int LeafPairs;
    int LeafWidth;
    int GantryAngle;
    int CollimatorAngle;
    double MonitorUnits;
public:
    // constructor
//    Field() : LeafPairs(0), GantryAngle(0), CollimatorAngle(0), MonitorUnits(0.0){};
    virtual ~Field(){};// Virtual function dynamically determined at runtime (can be overwritten in derived class)
 //new constructor for dynamic memory allocation - must be parameterless
 Field(){
  LeafPairs=GantryAngle=CollimatorAngle=0;
  MonitorUnits=0.0;
 }

    //accessors
    void SetGantryAngle (int Gantry) { GantryAngle=Gantry;}
    void SetCollimatorAngle (int Colli) { CollimatorAngle=Colli;}
    void SetMonitorUnits (double MU) { MonitorUnits=MU;}
    int GetLeafPairs () const {return LeafPairs;}
    int GetLeafWidth () const {return LeafWidth;}
    int GetGantryAngle () const {return GantryAngle;}
    int GetCollimatorAngle () const {return CollimatorAngle;}
    double GetMonitorUnits () const {return MonitorUnits;}
};

class FieldSyn: public Field
{
private:
    int Y[41]; //arrays
    int X[80]; 
public:
    //constructor and destructor
    // constructor initialises values and arrays
 FieldSyn(){
  LeafPairs=40;
  LeafWidth=4;
/*    FieldSyn(){
*/ 
 int aY[]={-80,-76,-72,-68,-64,-60,-56,-52,-48,
   -44,-40,-36,-32,-28,-24,-20,-16,-12,
   -8,-4,0,4,8,12,16,20,24,28,32,36,34,
    40,44,48,52,56,60,64,68,72,76,80};
 memcpy(Y, aY, sizeof(Y)/sizeof(int));

 int aX[]={110,110,110,110,110,110,110,110,
   110,110,110,110,110,110,110,110,
   110,110,110,110,110,110,110,110,
   50,50,50,50,50,50,50,50,
   80,80,80,80,80,80,80,80,
   90,90,90,90,90,90,90,90,
   30,30,30,30,30,30,30,30,
   110,110,110,110,110,110,110,110,
   110,110,110,110,110,110,110,110,
   110,110,110,110,110,110,110,110};
 memcpy(X, aX, sizeof(X)/sizeof(int));
// LeafPairs = 40;
// LeafWidth = 4;

    }
    //destructor
    virtual ~FieldSyn(){};// Virtual function dynamically determined at runtime (can be overwritten in derived class)

 //accessors for arrays
 void GetYPosition () const {
  for(int i=0;i<LeafPairs;i++){
   cout << Y[i] << " i: " << i << endl;}}
 
};

// Field2.cpp
#include <iostream>
#include <cstdlib>
#include"Field_2.h"


using namespace std;


int main()
{

 int *NumBeams=0, Beams=1;// max 7 for testing purposes
 
 // define static input arrays for Gantry-, Collimator angle and MUs (testing purposes ONLY)

 int GAngle[]={0,52,103,154,206,257,309}, *pGAngle=0; // pointer to array elements
 int CAngle[]={1,3,5,7,5,3,1}, *pCAngle=0; // pointer to array elements
 double MU[]={5.76,
    10.34,
    17.36,
    25.01,
    35.43,
    42.17,
    55.00}, *pMU=0; //pointer to array elements

//  Initialise pointers 
 pGAngle=&GAngle[0];
 pCAngle=&CAngle[0];
 pMU=&MU[0];
 NumBeams=&Beams;// set ptr NumBeams to address of Beams variable

//   Field *pBeam;// Beam[6], *pBeam=0;
 FieldSyn *pBeam;

 try{
  pBeam=new FieldSyn[*NumBeams];
 } catch (bad_alloc xa){
  cout << "Allocation failure\n";
  return 1;
 }

    for(int i=0;i<Beams;i++){
    
 
 cout << "\nBeam : " << i << endl;

 pBeam->SetGantryAngle(*pGAngle);
    cout << "Gantry Angle : " << pBeam->GetGantryAngle() << endl;

    pBeam->SetCollimatorAngle(*pCAngle);
    cout << "Collimator Angle : " << pBeam->GetCollimatorAngle() << endl;

    pBeam->SetMonitorUnits(*pMU);
    cout << "Monitor Units : " << pBeam->GetMonitorUnits() << endl;

 cout << "Leaf width : " << pBeam->GetLeafWidth() << endl;
 cout << "Leaf pairs: " << pBeam->GetLeafPairs() << endl;

 cout << "Leaf Y position: " << endl;
 pBeam->GetYPosition();

 pGAngle++;
 pCAngle++; 
 pMU++;
 pBeam++; 
 }

 cout<< endl;

    delete [] pBeam; // calls FieldSyn destructor and releases memory (avoid memory "leak")
 return 0;

}

memcpy(Y, aY, sizeof(Y)/sizeof(int));