Merge pull request #37 from LLNL/fix-warnings

Fix compiler warnings

Author: tdrwenski

include/controlbasis.hpp

@@ -33,11 +33,11 @@ class ControlBasis {
         virtual int getNSplines() {return 0;};
 
         /* Variation of control parameters */
-        virtual double computeVariation(std::vector<double>& params, int carrierfreqID){return 0.0;};
-        virtual void computeVariation_diff(double* grad, std::vector<double>&params, double var_bar, int carrierfreqID){};
+        virtual double computeVariation(std::vector<double>& /*params*/, int /*carrierfreqID*/){return 0.0;};
+        virtual void computeVariation_diff(double* /*grad*/, std::vector<double>& /*params*/, double /*var_bar*/, int /*carrierfreqID*/){};
 
         /* Default: do nothing. For some control parameterizations, this can be used to enforce that the controls start and end at zero. E.g. the Splines will overwrite the parameters x of the first and last two splines by zero, so that the splines start and end at zero. */
-        virtual void enforceBoundary(double* x, int carrier_id) {};
+        virtual void enforceBoundary(double* /*x*/, int /*carrier_id*/) {};
 
         /* Evaluate the Basis(alpha, t) at time t using the coefficients coeff. */
         virtual void evaluate(const double t, const std::vector<double>& coeff, int carrier_freq_id, double* Blt1, double*Blt2) = 0;
@@ -198,8 +198,8 @@ class ConstantTransferFunction : public TransferFunction {
         ConstantTransferFunction(double constant_, std::vector<double> onofftimes);
         ~ConstantTransferFunction();
 
-        double eval(double x, double time) {return isOn(constant, time); }; 
-        double der(double x, double time) {return 0.0; }; 
+        double eval(double /*x*/, double time) {return isOn(constant, time); }; 
+        double der(double /*x*/, double /*time*/) {return 0.0; }; 
 };
 
 /*
@@ -212,7 +212,7 @@ class IdentityTransferFunction : public TransferFunction {
         ~IdentityTransferFunction();
 
         double eval(double x, double time) {return isOn(x, time); };
-        double der(double x, double time) {return isOn(1.0, time); };
+        double der(double /*x*/, double time) {return isOn(1.0, time); };
 };
 
 

include/mastereq.hpp

@@ -114,10 +114,10 @@ class MasterEq{
     void setTransferOnOffTimes(std::vector<double> tlist);
 
     /* Return the i-th oscillator */
-    Oscillator* getOscillator(const int i);
+    Oscillator* getOscillator(const size_t i);
 
     /* Return number of oscillators */
-    int getNOscillators();
+    size_t getNOscillators();
 
     /* Return dimension of vectorized system N^2 (for Lindblad solver) or N (for Schroedinger solver) */
     int getDim();
@@ -437,7 +437,7 @@ inline void L1decay(const int it, const int n, const int i, const int ip, const
 
 
 // Transpose of offdiagonal L1decay
-inline void L1decay_T(const int it, const int n, const int i, const int ip, const int stridei, const int strideip, const double* xptr, const double decayi, double* yre, double* yim){
+inline void L1decay_T(const int it, const int i, const int ip, const int stridei, const int strideip, const double* xptr, const double decayi, double* yre, double* yim){
   if (fabs(decayi) > 1e-12) {
       if (i > 0 && ip > 0) {
         double l1off = decayi * sqrt(i*ip);

include/optimproblem.hpp

@@ -20,7 +20,7 @@
 class OptimProblem {
 
   /* ODE stuff */
-  int ninit;                            /* Number of initial conditions to be considered (N^2, N, or 1) */
+  size_t ninit;                          /* Number of initial conditions to be considered (N^2, N, or 1) */
   int ninit_local;                      /* Local number of initial conditions on this processor */
   Vec rho_t0;                            /* Storage for initial condition of the ODE */
   Vec rho_t0_bar;                        /* Adjoint of ODE initial condition */

include/optimtarget.hpp

@@ -21,7 +21,7 @@ class OptimTarget{
                                       If target is a gate, this holds the transformed state VrhoV^\dagger.
                                       If target is read from file, this holds the target density matrix from that file. */
     InitialConditionType initcond_type;    /* Type of initial conditions */
-    std::vector<int> initcond_IDs;         /* Integer list for pure-state initialization */
+    std::vector<size_t> initcond_IDs;      /* Integer list for pure-state initialization */
     LindbladType lindbladtype;             /* Type of decoherence (lindblad vs schroedinger) */
 
     Vec aux;      /* auxiliary vector needed when computing the objective for gate optimization */

include/oscillator.hpp

@@ -48,18 +48,18 @@ class Oscillator {
     int dim_postOsc;               // Dimension of coupled subsystem following this oscillator
 
     Oscillator();
-    Oscillator(MapParam config, int id, std::vector<int> nlevels_all_, std::vector<std::string>& controlsegments, std::vector<std::string>& controlinitializations, double ground_freq_, double selfkerr_, double rotational_freq_, double decay_time_, double dephase_time_, std::vector<double> carrier_freq_, double Tfinal_, LindbladType lindbladtype_, std::default_random_engine rand_engine);
+    Oscillator(MapParam config, size_t id, std::vector<int> nlevels_all_, std::vector<std::string>& controlsegments, std::vector<std::string>& controlinitializations, double ground_freq_, double selfkerr_, double rotational_freq_, double decay_time_, double dephase_time_, std::vector<double> carrier_freq_, double Tfinal_, LindbladType lindbladtype_, std::default_random_engine rand_engine);
     virtual ~Oscillator();
 
     /* Return the constants */
-    int getNParams() { return params.size(); };
-    int getNLevels() { return nlevels; };
+    size_t getNParams() { return params.size(); };
+    size_t getNLevels() { return nlevels; };
     double getSelfkerr() { return selfkerr; }; 
     double getDetuning() { return detuning_freq; }; 
     double getDecayTime() {return decay_time; };
     double getDephaseTime() {return dephase_time; };
-    int getNSegments() {return basisfunctions.size(); };
-    int getNCarrierfrequencies() {return carrier_freq.size(); };
+    size_t getNSegments() {return basisfunctions.size(); };
+    size_t getNCarrierfrequencies() {return carrier_freq.size(); };
     ControlType getControlType(int isegment=0) {return basisfunctions[isegment]->getType(); };
     int getNSplines(int isegment=0) {return basisfunctions[isegment]->getNSplines();};
     double getRotFreq() {return (ground_freq - detuning_freq) / (2.0*M_PI); };

include/timestepper.hpp

@@ -50,17 +50,17 @@ class TimeStepper{
     bool storeFWD;       /* Flag that determines if primal states should be stored during forward evaluation */
 
     TimeStepper(); 
-    TimeStepper(MapParam config, MasterEq* mastereq_, int ntime_, double total_time_, Output* output_, bool storeFWD_); 
+    TimeStepper(MasterEq* mastereq_, int ntime_, double total_time_, Output* output_, bool storeFWD_); 
     virtual ~TimeStepper(); 
 
     /* Return the state at a certain time index */
-    Vec getState(int tindex);
+    Vec getState(size_t tindex);
 
     /* Solve the ODE forward in time with initial condition rho_t0. Return state at final time step */
     Vec solveODE(int initid, Vec rho_t0);
 
     /* Solve the adjoint ODE backwards in time from terminal condition rho_t0_bar */
-    void solveAdjointODE(int initid, Vec rho_t0_bar, Vec finalstate, double Jbar_penalty, double Jbar_penalty_dpdm, double Jbar_penalty_energy);
+    void solveAdjointODE(Vec rho_t0_bar, Vec finalstate, double Jbar_penalty, double Jbar_penalty_dpdm, double Jbar_penalty_energy);
 
     /* evaluate the penalty integral term */
     double penaltyIntegral(double time, const Vec x);
@@ -84,7 +84,7 @@ class TimeStepper{
 class ExplEuler : public TimeStepper {
   Vec stage;
   public:
-    ExplEuler(MapParam config, MasterEq* mastereq_, int ntime_, double total_time_, Output* output_, bool storeFWD_);
+    ExplEuler(MasterEq* mastereq_, int ntime_, double total_time_, Output* output_, bool storeFWD_);
     ~ExplEuler();
 
     /* Evolve state forward from tstart to tstop */
@@ -116,7 +116,7 @@ class ImplMidpoint : public TimeStepper {
   Vec tmp, err;                    /* Auxiliary vector for applying the neuman iterations */
 
   public:
-    ImplMidpoint(MapParam config, MasterEq* mastereq_, int ntime_, double total_time_, LinearSolverType linsolve_type_, int linsolve_maxiter_, Output* output_, bool storeFWD_);
+    ImplMidpoint(MasterEq* mastereq_, int ntime_, double total_time_, LinearSolverType linsolve_type_, int linsolve_maxiter_, Output* output_, bool storeFWD_);
     ~ImplMidpoint();
 
 
@@ -140,7 +140,7 @@ class CompositionalImplMidpoint : public ImplMidpoint {
   int order;
 
   public:
-    CompositionalImplMidpoint(MapParam config, int order_, MasterEq* mastereq_, int ntime_, double total_time_, LinearSolverType linsolve_type_, int linsolve_maxiter_, Output* output_, bool storeFWD_);
+    CompositionalImplMidpoint(int order_, MasterEq* mastereq_, int ntime_, double total_time_, LinearSolverType linsolve_type_, int linsolve_maxiter_, Output* output_, bool storeFWD_);
     ~CompositionalImplMidpoint();
 
     void evolveFWD(const double tstart, const double tstop, Vec x);

src/CMakeLists.txt

@@ -50,10 +50,6 @@ if(WITH_SLEPC)
     target_compile_options(quandary PRIVATE -DWITH_SLEPC)
 endif()
 
-# Suppress compiler warnings temporarily
-# TODO fix these and remove this!
-add_definitions(-w)
-
 install(
     TARGETS quandary
     RUNTIME DESTINATION bin

src/config.cpp

@@ -184,7 +184,6 @@ void MapParam::GetVecIntParam(std::string key, std::vector<int> &fillme, int def
 {
   std::map<std::string, std::string>::const_iterator it_value = this->find(key);
   std::string lineexp;
-  double val;
   if (it_value == this->end())
   {
     if (mpi_rank == 0 && !quietmode && warnme)

src/controlbasis.cpp

@@ -65,7 +65,7 @@ void BSpline2nd::evaluate(const double t, const std::vector<double>& coeff, int
 
 }
 
-void BSpline2nd::derivative(const double t, const std::vector<double>& coeff, double* coeff_diff, const double valbar1, const double valbar2, int carrier_freq_id) {
+void BSpline2nd::derivative(const double t, const std::vector<double>& /*coeff*/, double* coeff_diff, const double valbar1, const double valbar2, int carrier_freq_id) {
 
     /* Iterate over basis function */
     for (int l=0; l<nsplines; l++) {
@@ -242,7 +242,7 @@ void BSpline0::evaluate(const double t, const std::vector<double>& coeff, int ca
     }
 }
 
-void BSpline0::derivative(const double t, const std::vector<double>& coeff, double* coeff_diff, const double valbar1, const double valbar2, int carrier_freq_id) {
+void BSpline0::derivative(const double t, const std::vector<double>& /*coeff*/, double* coeff_diff, const double valbar1, const double valbar2, int carrier_freq_id) {
 
     // Figure out which basis function is active at this time point 
     int splineID = ceil((t-tstart)/dtknot - 0.5);
@@ -332,7 +332,7 @@ void TransferFunction::storeOnOffTimes(std::vector<double>onofftimes_){
 
     // Copy the list of time points that determine when the transfer functions are active
     onofftimes.clear();
-    for (int i=0; i<onofftimes_.size(); i++) {
+    for (size_t i=0; i<onofftimes_.size(); i++) {
         onofftimes.push_back( onofftimes_[i] );
     }   
 }

src/gate.cpp

@@ -17,19 +17,19 @@ Gate::Gate(std::vector<int> nlevels_, std::vector<int> nessential_, double time_
   final_time = time_;
   gate_rot_freq = gate_rot_freq_;
   lindbladtype = lindbladtype_;
-  for (int i=0; i<gate_rot_freq.size(); i++){
+  for (size_t i=0; i<gate_rot_freq.size(); i++){
     gate_rot_freq[i] *= 2.*M_PI;
   }
 
   /* Dimension of gate = \prod_j nessential_j */
   dim_ess = 1;
-  for (int i=0; i<nessential.size(); i++) {
+  for (size_t i=0; i<nessential.size(); i++) {
     dim_ess *= nessential[i];
   }
 
   /* Dimension of system matrix rho */
   dim_rho = 1;
-  for (int i=0; i<nlevels.size(); i++) {
+  for (size_t i=0; i<nlevels.size(); i++) {
     dim_rho *= nlevels[i];
   }
 
@@ -98,10 +98,10 @@ void Gate::assembleGate(){
   for (PetscInt row=0; row<dim_ess; row++){
     int r = row;
     double freq = 0.0;
-    for (int iosc=0; iosc<nlevels.size(); iosc++){
+    for (size_t iosc=0; iosc<nlevels.size(); iosc++){
       // compute dimension of essential levels of all following subsystems 
       int dim_post = 1;
-      for (int josc=iosc+1; josc<nlevels.size();josc++) {
+      for (size_t josc=iosc+1; josc<nlevels.size();josc++) {
         dim_post *= nessential[josc];
       }
       // compute the frequency