Remove commented deprecated C1, C1_AddOns and C4 classes

class ParticleDescriptor;

class mixMPI;

// /*! \brief Representation of the FORTRAN C1 common blocks.

//  *

//  * C1 common blocks are used to store vector field expansions and geometric

//  * properties, such as sphere sizes, positions and cross-sections. These are

//  * used by functions such as `aps`, `diel`, `pwma`, `rabas`, `sscr0`, `sscr2`,

//  * `wmamp`, `wmasp` and `dme`. QUESTION: correct?

//  *

//  * Due to the necessity to share the class contents with many functions that

//  * need to read and update various fields, all shared members of C1 are declared

//  * public (i.e., the class is just a structure with more advanced constructor

//  * and destroyer). Further development may go in the direction of creating

//  * a better encapsulation, either by unpacking the contents (recommended) or

//  * by creating public methods to access protected fields (standard way, but not

//  * recommended for HPC applications).

//  */

// class C1 {

// protected:

//   //! \brief Maximum order of field expansion.

//   int lm;

//   //! \brief Maximum order of internal field expansion.

//   int li;

//   //! \brief Maximum order of external field expansion.

//   int le;

//   //! \brief Contiguous RMI vector.

//   dcomplex *vec_rmi;

//   //! \brief Contiguous REI vector.

//   dcomplex *vec_rei;

//   //! \brief Contiguous W vector.

//   dcomplex *vec_w;

//   //! \brief Contiguous VINTS vector

//   dcomplex *vec_vints;

// public:

//   //! \brief Number of spheres.

//   int nsph;

//   //! \brief NLEMT = 2 * LE * (LE + 2).

//   int nlemt;

//   //! \brief Number of configurations

//   int configurations;

//   //! \brief QUESTION: definition?

//   dcomplex **rmi;

//   //! \brief QUESTION: definition?

//   dcomplex **rei;

//   //! \brief QUESTION: definition?

//   dcomplex **w;

//   //! \brief QUESTION: definition?

//   dcomplex *fsas;

//   //! \brief QUESTION: definition?

//   dcomplex *vint;

//   //! \brief Components of the scattered field intensities.

//   dcomplex **vints;

//   //! \brief Single sphere scattering cross-sections.

//   double *sscs;

//   //! \brief Single sphere extinction cross-sections.

//   double *sexs;

//   //! \brief Single sphere absorption cross-sections.

//   double *sabs;

//   //! \brief Single sphere scattering efficiencies.

//   double *sqscs;

//   //! \brief Single sphere extinction efficiencies.

//   double *sqexs;

//   //! \brief Single sphere absorption efficiencies.

//   double *sqabs;

//   //! \brief Single sphere geometric cross-section vector.

//   double *gcsv;

//   //! \brief Vector of sphere X coordinates.

//   double *rxx;

//   //! \brief Vector of sphere X coordinates.

//   double *ryy;

//   //! \brief Vector of sphere X coordinates.

//   double *rzz;

//   //! \brief Vector of sphere radii.

//   double *ros;

//   //! \brief Matrix of spherical layer break radii. QUESTION: correct?

//   double **rc;

//   //! \brief Vector of spherical component identifiers.

//   int *iog;

//   //! \brief Vector of numbers of spherical layers.

//   int *nshl;

//   //! \brief QUESTION: definition?

//   dcomplex ***sas;

//   /*! \brief C1 instance constructor.

//    *

//    * \param gconf: `GeometryConfiguration *` Pointer to a geometry configuration object.

//    * \param sconf: `ScattererConfiguration *` Pointer to a scatterer configuration object.

//    */

//   C1(GeometryConfiguration *gconf, ScattererConfiguration *sconf);

//   /*! \brief C1 instance constructor copying all contents from a preexisting template

//    *

//    * \param rhs: `C1` preexisting template.

//    */

//   C1(const C1& rhs);

// #ifdef MPI_VERSION

//   /*! \brief C1 instance constructor copying all contents off MPI broadcast from MPI process 0

//    *

//    * \param mpidata: `mixMPI *` pointer to MPI data structure.

//    */

//   C1(const mixMPI *mpidata);

//   /*! \brief send C1 instance from MPI process 0 via MPI broadcasts to all other processes

//    *

//    * \param mpidata: `mixMPI *` pointer to MPI data structure.

//    */

//   void mpibcast(const mixMPI *mpidata);

// #endif

//   //! \brief C1 instance destroyer.

//   ~C1();

// };

/*! \brief Representation of the FORTRAN C2 blocks.

 *

 */

};

// /*! \brief Representation of the FORTRAN C4 blocks.

//  */

// class C4 {

// public:

//   //! \brief LITPO = 2 * LI + 1.

//   int litpo;

//   //! \brief LITPOS = LITPO * LITPO

//   int litpos;

//   //! \brief LMPO = LM + 1.

//   int lmpo;

//   //! \brief LMTPO = 2 * LM + 1.

//   int lmtpo;

//   //! \brief LMTPOS = LMTPO * LMTPO.

//   int lmtpos;

//   //! \brief Internal field expansion order.

//   int li;

//   //! \brief NLIM = LI * (LI + 2)

//   int nlim;

//   //! \brief External field expansion order.

//   int le;

//   //! \brief NLEM = LE * (LE + 2)

//   int nlem;

//   //! \brief Maximum field expansion order.

//   int lm;

//   //! \brief Number of spheres.

//   int nsph;

//   //! \brief NV3J = (LM * (LM + 1) * (2 * LM + 7)) / 6

//   int nv3j;

//   /*! \brief C4 instance constructor.

//    *

//    * \param gconf: `GeometryConfiguration*` Pointer to a GeometryConfiguration instance.

//    */

//   C4(GeometryConfiguration *gconf);

//   /*! \brief C4 instance constructor copying its contents from a preexisting object.

//    *

//    * \param rhs: `C4&` Reference of the object to be copied.

//    */

//   C4(const C4& rhs);

//   /*! \brief C4 instance destroyer.

//    */

//   ~C4();

// #ifdef MPI_VERSION

//   /*! \brief C4 instance constructor copying all contents off MPI broadcast from MPI process 0

//    *

//    * \param mpidata: `mixMPI *` pointer to MPI data structure.

//    */

//   C4(const mixMPI *mpidata);

//   /*! \brief send C4 instance from MPI process 0 via MPI broadcasts to all other processes

//    *

//    * \param mpidata: `mixMPI *` pointer to MPI data structure.

//    */

//   void mpibcast(const mixMPI *mpidata);

// #endif

// };

// /*! \brief Vectors and matrices that are specific to cluster C1 blocks.

//  *

//  */

// class C1_AddOns {

// protected:

//   //! \brief Number of spheres.

//   int nsph;

//   //! \brief NLEMT = 2 * (LE * (LE + 2))

//   int nlemt;

//   //! \brief LMPO = LM + 1

//   int lmpo;

//   //! \brief LITPO = 2 * LI + 1

//   int litpo;

//   //! \brief LMTPO = 2 * LM + 1

//   int lmtpo;

//   //! \brief LITPOS = LITPO * LITPO

//   int litpos;

//   //! \brief LMTPOS = LMTPO * LMTPO

//   int lmtpos;

//   //! \brief NV3J = (LM * (LM + 1) * (2 * LM + 7)) / 6

//   int nv3j;

//   //! \brief Maximum field expansion order.

//   int lm;

// public:

//   //! \brief QUESTION: definition?

//   dcomplex *vh;

//   //! \brief QUESTION: definition?

//   dcomplex *vj0;

//   //! \brief QUESTION: definition?

//   dcomplex *vj;

//   //! \brief QUESTION: definition?

//   dcomplex *vyhj;

//   //! \brief QUESTION: definition?

//   dcomplex *vyj0;

//   //! \brief QUESTION: definition?

//   dcomplex **am0m;

//   //! \brief Vectorized AM0M matrix.

//   dcomplex *am0v;

//   //! \brief QUESTION: definition?

//   dcomplex *vintm;

//   //! \brief QUESTION: definition?

//   dcomplex *vintt;

//   //! \brief QUESTION: definition?

//   dcomplex **fsac;

//   //! \brief QUESTION: definition?

//   dcomplex **sac;

//   //! \brief QUESTION: definition?

//   dcomplex **fsacm;

//   //! \brief QUESTION: definition?

//   double *scsc;

//   //! \brief QUESTION: definition?

//   dcomplex *scscp;

//   //! \brief QUESTION: definition?

//   double *ecsc;

//   //! \brief QUESTION: definition?

//   double *ecscm;

//   //! \brief QUESTION: definition?

//   double *scscm;

//   //! \brief QUESTION: definition?

//   dcomplex *ecscp;

//   //! \brief QUESTION: definition?

//   dcomplex *scscpm;

//   //! \brief QUESTION: definition?

//   dcomplex *ecscpm;

//   //! \brief QUESTION: definition?

//   double *v3j0;

//   //! \brief QUESTION: definition?

//   double *sscs;

//   //! \brief QUESTION: definition?

//   int **ind3j;

//   /*! \brief C1_AddOns instance constructor.

//    *

//    * \param c4: `C4 *` Pointer to a C4 structure.

//    */

//   C1_AddOns(C4 *c4);

//   /*! \brief C1_AddOns instance constructor copying contents from a preexisting object.

//    *

//    * \param rhs: `C1_AddOns` preexisting object to copy from.

//    */

//   C1_AddOns(const C1_AddOns& rhs);

//   //! \brief C1_AddOns instance destroyer.

//   ~C1_AddOns();

// #ifdef MPI_VERSION

//   /*! \brief C1_AddOns instance constructor copying all contents off MPI broadcast from MPI process 0

//    *

//    * \param mpidata: `mixMPI *` pointer to MPI data structure.

//    */

//   C1_AddOns(const mixMPI *mpidata);

//   /*! \brief send C1_AddOns instance from MPI process 0 via MPI broadcasts to all other processes

//    *

//    * \param mpidata: `mixMPI *` pointer to MPI data structure.

//    */

//   void mpibcast(const mixMPI *mpidata);

// #endif

// };

/*! \brief Representation of the FORTRAN C6 blocks.

 */

class C6 {