libhoomd/computes/Compute.cc

   1 /*
   2 Highly Optimized Object-oriented Many-particle Dynamics -- Blue Edition
   3 (HOOMD-blue) Open Source Software License Copyright 2009-2014 The Regents of
   4 the University of Michigan All rights reserved.
   5
   6 HOOMD-blue may contain modifications ("Contributions") provided, and to which
   7 copyright is held, by various Contributors who have granted The Regents of the
   8 University of Michigan the right to modify and/or distribute such Contributions.
   9
  10 You may redistribute, use, and create derivate works of HOOMD-blue, in source
  11 and binary forms, provided you abide by the following conditions:
  12
  13 * Redistributions of source code must retain the above copyright notice, this
  14 list of conditions, and the following disclaimer both in the code and
  15 prominently in any materials provided with the distribution.
  16
  17 * Redistributions in binary form must reproduce the above copyright notice, this
  18 list of conditions, and the following disclaimer in the documentation and/or
  19 other materials provided with the distribution.
  20
  21 * All publications and presentations based on HOOMD-blue, including any reports
  22 or published results obtained, in whole or in part, with HOOMD-blue, will
  23 acknowledge its use according to the terms posted at the time of submission on:
  24 http://codeblue.umich.edu/hoomd-blue/citations.html
  25
  26 * Any electronic documents citing HOOMD-Blue will link to the HOOMD-Blue website:
  27 http://codeblue.umich.edu/hoomd-blue/
  28
  29 * Apart from the above required attributions, neither the name of the copyright
  30 holder nor the names of HOOMD-blue's contributors may be used to endorse or
  31 promote products derived from this software without specific prior written
  32 permission.
  33
  34 Disclaimer
  35
  36 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' AND
  37 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  38 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR ANY
  39 WARRANTIES THAT THIS SOFTWARE IS FREE OF INFRINGEMENT ARE DISCLAIMED.
  40
  41 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  42 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  43 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  44 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  45 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  46 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  47 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48 */
  49
  50 // Maintainer: joaander
  51
  52 #ifdef WIN32
  53 #pragma warning( push )
  54 #pragma warning( disable : 4244 )
  55 #endif
  56
  57 #include <boost/python.hpp>
  58 using namespace boost::python;
  59
  60 #include <iostream>
  61 #include <stdexcept>
  62 using namespace std;
  63
  64 #include "Compute.h"
  65
  66 /*! \file Compute.cc
  67     \brief Contains code for the Compute class
  68 */
  69
  70 /*! \param sysdef SystemDefinition this compute will act on. Must not be NULL.
  71     \post The Compute is constructed with the given particle data and a NULL profiler.
  72 */
  73 Compute::Compute(boost::shared_ptr<SystemDefinition> sysdef) : m_sysdef(sysdef), m_pdata(m_sysdef->getParticleData()),
  74         exec_conf(m_pdata->getExecConf()), m_force_compute(false), m_last_computed(0), m_first_compute(true)
  75     {
  76     // sanity check
  77     assert(m_sysdef);
  78     assert(m_pdata);
  79     m_exec_conf = exec_conf;
  80     }
  81
  82 /*! \param num_iters Number of iterations to average for the benchmark
  83     \returns Milliseconds of execution time per calculation
  84     Derived classes can optionally implement this method. */
  85 double Compute::benchmark(unsigned int num_iters)
  86     {
  87     m_exec_conf->msg->error() << "This compute doesn't support benchmarking" << endl;
  88     throw runtime_error("Error benchmarking compute");
  89     return 0.0;
  90     }
  91
  92 /*! It is useful for the user to know where computation time is spent, so all Computes
  93     should profile themselves. This method sets the profiler for them to use.
  94     This method does not need to be called, as Computes will not profile themselves
  95     on a NULL profiler
  96     \param prof Pointer to a profiler for the compute to use. Set to NULL
  97         (boost::shared_ptr<Profiler>()) to stop the
  98         analyzer from profiling itself.
  99     \note Derived classes MUST check if m_prof is set before calling any profiler methods.
 100 */
 101 void Compute::setProfiler(boost::shared_ptr<Profiler> prof)
 102     {
 103     m_prof = prof;
 104     }
 105
 106 /*! \param timestep Current time step
 107     \returns true if computations should be performed, false if they have already been done
 108         at this \a timestep.
 109     \note This method is designed to only be called once per call to compute() like so:
 110 \code
 111 void SomeClass::compute(unsgned int timestep)
 112     {
 113     if (!shouldCompute(timestep))
 114         return;
 115     ... do compute tasks
 116     }
 117 \endcode
 118 */
 119 bool Compute::shouldCompute(unsigned int timestep)
 120     {
 121     // handle case where no computation has been performed yet
 122     if (m_first_compute)
 123         {
 124         m_first_compute = false;
 125         m_last_computed = timestep;
 126         return true;
 127         }
 128
 129     // Update if computation is enforced, but leave m_last_computed unchanged
 130     // (such that after a forced compute(), still a regular compute() is possible)
 131     if (m_force_compute)
 132         {
 133         m_force_compute = false;
 134         return true;
 135         }
 136
 137     // otherwise, we update if the last computed timestep is less than the current
 138     if (m_last_computed != timestep)
 139         {
 140         m_last_computed = timestep;
 141         return true;
 142         }
 143
 144
 145     // failing the above, we perform no computation
 146     return false;
 147     }
 148
 149 void Compute::forceCompute(unsigned int timestep)
 150     {
 151     m_force_compute = true;
 152
 153     compute(timestep);
 154     }
 155
 156 //! Wrapper class for handling virtual methods of Compute in python
 157 class ComputeWrap : public Compute, public wrapper<Compute>
 158     {
 159     public:
 160         //! Constructor
 161         /*! \param sysdef Particle data to pass on to the base class */
 162         ComputeWrap(boost::shared_ptr<SystemDefinition> sysdef) : Compute(sysdef)
 163             {
 164             }
 165
 166         //! Calls overidden Compute::compute()
 167         /*! \param timestep Parameter to pass on to the base class method */
 168         void compute(unsigned int timestep)
 169             {
 170             this->get_override("compute")(timestep);
 171             }
 172
 173         //! Calls overidden Compute::compute()
 174         /*! \param num_iters Parameter to pass on to the base class method */
 175         double benchmark(unsigned int num_iters)
 176             {
 177             if (override f = this->get_override("benchmark"))
 178                 return f(num_iters);
 179             else
 180                 return Compute::benchmark(num_iters);
 181             }
 182
 183         //! Calls overridden Compute::printStats()
 184         void printStats()
 185             {
 186             if (override f = this->get_override("printStats"))
 187                 f();
 188             else
 189                 Compute::printStats();
 190             }
 191
 192         //! Default implementation of Compute::printStats()
 193         void default_printStats()
 194             {
 195             this->Compute::printStats();
 196             }
 197
 198         // A decision has been made to not currently support deriving new compute classes in python
 199         // thus, the internal methods of Compute that are only needed for that purpose do not need to be
 200         // exported, only the public interface
 201         //protected:
 202         // Calls overridden Compute::shouldCompute()
 203         /* \param timestep Parameter to pass on to the base class method */
 204         /*bool shouldCompute(unsigned int timestep)
 205             {
 206             if (override f = this->get_override("shouldCompute"))
 207                 return f(timestep);
 208             else
 209                 return Compute::shouldCompute(timestep);
 210             }*/
 211
 212         // Default implementation of Compute::shouldCompute()
 213         /* \param timestep Parameter to pass on to the base class method */
 214         /*bool default_shouldCompute(unsigned int timestep)
 215             {
 216             return this->Compute::shouldCompute(timestep);
 217             }
 218
 219         // The python export needs to be a friend to export protected members
 220         friend void export_Compute();*/
 221     };
 222
 223 void export_Compute()
 224     {
 225     class_<ComputeWrap, boost::shared_ptr<ComputeWrap>, boost::noncopyable>("Compute", init< boost::shared_ptr<SystemDefinition> >())
 226     .def("compute", pure_virtual(&Compute::compute))
 227     .def("benchmark", pure_virtual(&Compute::benchmark))
 228     .def("printStats", &Compute::printStats, &ComputeWrap::default_printStats)
 229     .def("setProfiler", &Compute::setProfiler)
 230     ;
 231     }
 232
 233 #ifdef WIN32
 234 #pragma warning( pop )
 235 #endif