Context Navigation

-              rd12d621
+              r28c025
     LOG(1, "INFO: Creating VMGJob.");
     FragmentJob::ptr testJob(
         new VMGJob(next_id, iter->density.begin, iter->density.size, iter->density.level, iter->density.sampled_grid) );
+        new VMGJob(next_id, iter->sampled_grid) );
     jobs.push_back(testJob);
+  }
 …
     const int level = LEVEL;
     const int GRID = pow(2, level);
     std::vector<double> full_sampled_grid(GRID*GRID*GRID, 0.);
+    std::vector<double> full_sample(GRID*GRID*GRID, 0.);
     double begin[NDIM] = { 0., 0., 0. };
     const RealSpaceMatrix& M = World::getInstance().getDomain().getM();
 …
     ASSERT( M.determinant() == size*size*size,
         "createLongRangeJobs() - current domain matrix "+toString(M)+" is not cubic.");
+    const SamplingGrid full_sampled_grid(begin, size, level, full_sample);
     const JobId_t next_id = controller.getAvailableId();
     FragmentJob::ptr testJob(
         new VMGJob(next_id, begin, size, level, full_sampled_grid) );
+        new VMGJob(next_id, full_sampled_grid) );
     jobs.push_back(testJob);
+  }

src/Jobs/MPQCData.cpp

-              rd12d621
+              r28c025
 #include "CodePatterns/Log.hpp"
 #include "LinearAlgebra/defs.hpp"
+MPQCData::MPQCData(const SamplingGridProperties &_props) :
+  sampled_grid(_props)
+{}
+MPQCData::MPQCData()
+{}
 MPQCData::energy_t::energy_t() :

-              rd12d621
+              r28c025
 #include <vector>
+#include "Jobs/Grid/SamplingGrid.hpp"
 class MPQCCommandJob;
 class MPQCCommandJobTest;
 …
   friend std::ostream & operator<<(std::ostream &ost, const MPQCData &data);
 public:
+  /** Constructor for class MPQCData with full sampling information.
+   *
+   * \param _props properties of the grid
+   */
+  MPQCData(const SamplingGridProperties &_props);
+  /** Default Constructor for class MPQCData.
+   *
+   */
+  MPQCData();
   bool operator==(const MPQCData &other) const;
 …
   /// Density
+  struct density_t {
+    //!> Begin (min coordinates) of grid in real space
+    double begin[3];
+    //!> edge length of cubic(!) domain
+    double size;
+    //!> level of the grid, hence \f$2^\text{level}\f$
+    int level;
+    //!> typedef for vector of samples grids
+    typedef std::vector<double> grid_type;
+    //!> vector of sample points in order x, y, z
+    grid_type sampled_grid;
+  } density;
+  SamplingGrid sampled_grid;
   /// Timing structure
 …
     ar & energies.eigenvalues;
     ar & forces;
+    int i;
+    for (int i=0; i<3; ++i)
+      ar & density.begin[i];
+    ar & density.size;
+    ar & density.level;
+    ar & density.sampled_grid;
+    ar & sampled_grid;
     ar & times.walltime;
     ar & times.cputime;

-              rd12d621
+              r28c025
   FragmentJob(_JobId),
   inputfile(_inputfile),
+  size(_size),
+  level(_level)
+{
+  for (int i=0; i<3; ++i)
+    begin[i] = _begin[i];
+}
+  grid(_begin, _size, _level)
+{}
 MPQCJob::MPQCJob() :
+  FragmentJob(JobId::IllegalJob),
+  size(0.),
+  level(0)
+  FragmentJob(JobId::IllegalJob)
 {}

-              rd12d621
+              r28c025
 #include "JobMarket/Jobs/FragmentJob.hpp"
+#include "Jobs/Grid/SamplingGridProperties.hpp"
 #include <string>
 …
 private:
   //!> contents of the input file
+  //!> contents of inputfile
   const std::string inputfile;
+  //!> offset of grid
+  double begin[3];
+  //!> size of grid, i.e. edge length of cubic(!) domain
+  const double size;
+  //!> level, i.e. \f$2^{\text{level}}\f$ grid points per axis
+  const int level;
+  //!> information for how to sample the density
+  const SamplingGridProperties grid;
 private:
 …
     ar & boost::serialization::base_object<FragmentJob>(*this);
     ar & const_cast<std::string &>(inputfile);
+    int i;
+    for (i=0; i<3; ++i)
+      ar & begin[i];
+    ar & const_cast<double &>(size);
+    ar & const_cast<int &>(level);
+    ar & const_cast<SamplingGridProperties &>(grid);
+  }
 };

-              rd12d621
+              r28c025
 JOBSSOURCE += \
         Jobs/InterfaceVMGJob.cpp \
+        Jobs/VMGJob.cpp
+        Jobs/VMGJob.cpp \
+        Jobs/Grid/SamplingGrid.cpp \
+        Jobs/Grid/SamplingGridProperties.cpp
 endif
 …
 JOBSHEADER += \
         Jobs/InterfaceVMGJob.hpp \
+        Jobs/VMGJob.hpp
+        Jobs/VMGJob.hpp \
+        Jobs/Grid/SamplingGrid.hpp \
+        Jobs/Grid/SamplingGridProperties.hpp
 endif

-              rd12d621
+              r28c025
 VMGJob::VMGJob(
     const JobId_t _JobId,
+    const double _begin[3],
+    const double _size,
+    const int _level,
+    const std::vector< double > &_sampled_input) :
+    const SamplingGrid _density_grid) :
   FragmentJob(_JobId),
+  size(_size),
+  level(_level),
+  sampled_input(_sampled_input)
+{
+  for (size_t i=0; i<3; ++i)
+    begin[i] = _begin[i];
+}
+  density_grid(_density_grid)
+{}
 VMGJob::VMGJob() :
+  FragmentJob(JobId::IllegalJob),
+  size(0.),
+  level(0)
+  FragmentJob(JobId::IllegalJob)
 {}
 …
   new DiscretizationPoissonFD(4);
   new VMGInterfaces::InterfaceVMGJob(
       sampled_input,
+      density_grid.sampled_grid,
       boundary,
 ,
       level,
       Vector(begin),
       size);
+      density_grid.level,
+      Vector(density_grid.begin),
+      density_grid.size);
   new LevelOperatorCS(Stencils::RestrictionFullWeight, Stencils::InterpolationTrilinear);
   new Givens<SolverSingular>();

-              rd12d621
+              r28c025
 #include "JobMarket/Jobs/FragmentJob.hpp"
+#include "Jobs/Grid/SamplingGrid.hpp"
 #include <vector>
 …
    */
   VMGJob(const JobId_t _JobId,
+      const double _begin[3],
+      const double _size,
+      const int _level,
+      const std::vector< double > &_sampled_input);
+      const SamplingGrid density_grid);
   virtual ~VMGJob();
 …
 private:
+  double begin[3];
+  const double size;
+  const int level;
+  //!> contents of the input file
+  const std::vector< double > sampled_input;
+  //!> sampled density required as input
+  const SamplingGrid density_grid;
 private:
 …
+  {
     ar & boost::serialization::base_object<FragmentJob>(*this);
+    int i;
+    for (i=0; i< 3; ++i)
+      ar & begin[i];
+    ar & const_cast< double &>(size);
+    ar & const_cast< int &>(level);
+    ar & const_cast< std::vector< double > &>(sampled_input);
+    ar & const_cast< SamplingGrid &>(density_grid);
+  }
 };

Note: See TracChangeset for help on using the changeset viewer.