PropRecorder.h

// -*-c++-*-
//----------------------------------------------------------------------------
//  XC program; finite element analysis code
//  for structural analysis and design.
//
//  Copyright (C)  Luis C. Pérez Tato
//
//  This program derives from OpenSees <http://opensees.berkeley.edu>
//  developed by the  «Pacific earthquake engineering research center».
//
//  Except for the restrictions that may arise from the copyright
//  of the original program (see copyright_opensees.txt)
//  XC is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or 
//  (at your option) any later version.
//
//  This software is distributed in the hope that it will be useful, but 
//  WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details. 
//
//
// You should have received a copy of the GNU General Public License 
// along with this program.
// If not, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------------
//PropRecorder.h
                                                                        
#ifndef PropRecorder_h
#define PropRecorder_h

#include <utility/recorder/DomainRecorderBase.h>
#include "utility/kernel/python_utils.h"

namespace XC {

//
class PropRecorder: public DomainRecorderBase
  {
  protected:
    std::string CallbackSetup; 
    std::string CallbackRecord; 
    std::string CallbackRestart; 
    int lastCommitTag; 
    double lastTimeStamp; 
    
    double deltaT; 
    double nextTimeStampToRecord; 
    
    void callSetupCallback(const int &,const double &);
    template <class Container>
    void callRecordCallback(Container &c,const int &,const double &);
    template <class Container>
    void callRestartCallback(Container &c);
  public:
    PropRecorder(int classTag, Domain *ptr_dom= nullptr);

    std::string getCurrentCombinationName(void) const;

    inline int getLastCommitTag(void) const
      { return lastCommitTag; }
    inline double getLastTimeStamp(void) const
      { return lastTimeStamp; }
    double getCurrentTime(void) const;
    double getCommittedTime(void) const;
    int getCommitTag(void) const;

    void setCallbackSetup(const std::string &);
    std::string getCallbackSetup(void) const;
    void setCallbackRecord(const std::string &);
    std::string getCallbackRecord(void) const;
    void setCallbackRestart(const std::string &);
    std::string getCallbackRestart(void) const;
    void setDeltaT(const double &);
    double getDeltaT(void) const;

  };

template <class Container>
void XC::PropRecorder::callRecordCallback(Container &c,const int &commitTag,const double &timeStamp)
  {
    this->callSetupCallback(commitTag,timeStamp);
    for(typename Container::iterator i= c.begin();i!=c.end();i++)
      {
    typename Container::value_type tmp= *i;
        if(tmp)
          {
            boost::python::object pyObj(boost::ref(*tmp));
            CommandEntity_exec(pyObj,CallbackRecord);
          }
        else
      std::cerr << getClassName() << "::" << __FUNCTION__
                << "; pointer is null." << std::endl;
      }
  }

template <class Container>
void PropRecorder::callRestartCallback(Container &c)
  {
    for(typename Container::iterator i= c.begin();i!=c.end();i++)
      {
    typename Container::value_type tmp= *i;
        if(tmp)
          {
            boost::python::object pyObj(boost::ref(*tmp));
            CommandEntity_exec(pyObj,this->CallbackRestart);
          }
        else
      std::cerr << getClassName() << "::" << __FUNCTION__
                << "; pointer is null." << std::endl;
      }
  }
 
} // end of XC namespace

#endif