MaterialVector.h

//----------------------------------------------------------------------------
//  XC program; finite element analysis code
//  for structural analysis and design.
//
//  Copyright (C)  Luis Claudio 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
//  under the terms of the GNU General Public License 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/>.
//----------------------------------------------------------------------------
//MaterialVector.h

#ifndef MaterialVector_h
#define MaterialVector_h

#include <vector>
#include "xc_utils/src/nucleo/EntCmd.h"
#include "material/section/ResponseId.h"
#include "utility/actor/actor/MovableID.h"
#include "utility/matrix/Vector.h"


namespace XC {

//
template <class MAT>
class MaterialVector: public std::vector<MAT *>, public EntCmd, public MovableObject
  {
  protected:
    void clear_materials(void);
    void clearAll(void);
    void alloc(const std::vector<MAT *> &mats);


    DbTagData &getDbTagData(void) const;
    int sendData(CommParameters &);  
    int recvData(const CommParameters &);
  public:
    typedef typename std::vector<MAT *> mat_vector;
    typedef typename mat_vector::iterator iterator;
    typedef typename mat_vector::reference reference;
    typedef typename mat_vector::const_reference const_reference;

    MaterialVector(const size_t &nMat,const MAT *matModel= nullptr);
    MaterialVector(const MaterialVector<MAT> &);
    MaterialVector<MAT> &operator=(const MaterialVector<MAT> &);
    ~MaterialVector(void)
      { clearAll(); }

    void setMaterial(const MAT *);
    void setMaterial(size_t i,MAT *);
    void setMaterial(const MAT *,const std::string &tipo);
    bool empty(void) const;
    int commitState(void);
    int revertToLastCommit(void);
    int revertToStart(void);

    void setInitialGeneralizedStrains(const std::vector<Vector> &);
    void addInitialGeneralizedStrains(const std::vector<Vector> &);
    void zeroInitialGeneralizedStrains(void);

    size_t getGeneralizedStressSize(void) const;
    size_t getGeneralizedStrainSize(void) const;
    m_double getGeneralizedStresses(void) const;
    m_double getGeneralizedStrains(void) const;
    const Vector &getMeanGeneralizedStress(void) const;
    const Vector &getMeanGeneralizedStrain(void) const;
    double getMeanGeneralizedStrain(const int &defID) const;
    double getMeanGeneralizedStress(const int &defID) const;
    double getMeanGeneralizedStrainByName(const std::string &) const;
    double getMeanGeneralizedStressByName(const std::string &) const;
    m_double getGeneralizedStrain(const int &defID) const;
    m_double getGeneralizedStress(const int &defID) const;

    int sendSelf(CommParameters &);
    int recvSelf(const CommParameters &);
  };

template <class MAT>
MaterialVector<MAT>::MaterialVector(const size_t &nMat,const MAT *matModel)
  : std::vector<MAT *>(nMat,nullptr), MovableObject(MAT_VECTOR_TAG)
  {
    if(matModel)
      {
        for(iterator i= mat_vector::begin();i!=mat_vector::end();i++)
          {
            (*i)= matModel->getCopy();
            if(!(*i))
              std::cerr << nombre_clase() << "::" << __FUNCTION__
                << "; failed allocate material model pointer\n";
          }
      }
  }

template <class MAT>
void MaterialVector<MAT>::alloc(const std::vector<MAT *> &mats)
  {
    clearAll();
    const size_t nMat= mats.size();
    this->resize(nMat);
    for(size_t i= 0;i<nMat;i++)
      {
        if(mats[i])
          {
            (*this)[i]= mats[i]->getCopy();
            if(!(*this)[i])
              std::cerr << nombre_clase() << "::" << __FUNCTION__
                << "; failed allocate material model pointer\n";
          }
      }
  }

template <class MAT>
MaterialVector<MAT>::MaterialVector(const MaterialVector<MAT> &otro)
  : std::vector<MAT *>(otro.size(),nullptr), MovableObject(MAT_VECTOR_TAG)
  { alloc(otro); }

template <class MAT>
MaterialVector<MAT> &MaterialVector<MAT>::operator=(const MaterialVector<MAT> &otro)
  { 
    alloc(otro);
    return *this;
  }

template <class MAT>
void MaterialVector<MAT>::setMaterial(const MAT *new_mat)
  {
    clear_materials();
    if(new_mat)
      {
        for(iterator i= mat_vector::begin();i!=mat_vector::end();i++)
          {
            (*i)= new_mat->getCopy();
            if(!(*i))
              std::cerr << nombre_clase() << "::" << __FUNCTION__
                << "; failed allocate material model pointer\n";
          }
      }
  }

template <class MAT>
void MaterialVector<MAT>::setMaterial(const MAT *new_mat, const std::string &tipo)
  {
    clear_materials();
    if(new_mat)
      {
        for(iterator i= mat_vector::begin();i!=mat_vector::end();i++)
          {
            (*i)= new_mat->getCopy(tipo.c_str());
            if(!(*i))
              std::cerr << nombre_clase() << "::" << __FUNCTION__
                << "; failed allocate material model pointer\n";
          }
      }
  }

template <class MAT>
void MaterialVector<MAT>::setMaterial(size_t i,MAT *new_mat)
  {
    if((*this)[i])
      delete (*this)[i];
    (*this)[i]= new_mat;
  }

template <class MAT>
void MaterialVector<MAT>::clear_materials(void)
  {
    for(iterator i= mat_vector::begin();i!=mat_vector::end();i++)
      {
        if(*i) delete (*i);
          (*i)= nullptr;
      }
  }

template <class MAT>
bool MaterialVector<MAT>::empty(void) const
  {
    if(mat_vector::empty())
      return true;
    else
      return ((*this)[0]==nullptr);
  }

template <class MAT>
void MaterialVector<MAT>::clearAll(void)
  {
    clear_materials();
    std::vector<MAT *>::clear();
  }


template <class MAT>
int MaterialVector<MAT>::commitState(void)
  {
    int retVal= 0;

    for(iterator i=mat_vector::begin();i!=mat_vector::end();i++)
      retVal+= (*i)->commitState();
    return retVal;
  }

template <class MAT>
int MaterialVector<MAT>::revertToLastCommit(void)
  {
    int retVal= 0;

    for(iterator i=mat_vector::begin();i!=mat_vector::end();i++)
      retVal+= (*i)->revertToLastCommit() ;
    return retVal;
  }


template <class MAT>
int MaterialVector<MAT>::revertToStart(void)
  {
    int retVal = 0;

    for(iterator i=mat_vector::begin();i!=mat_vector::end();i++)
      retVal+= (*i)->revertToStart() ;
    return retVal;
  }

template <class MAT>
size_t MaterialVector<MAT>::getGeneralizedStressSize(void) const
  { return (*this)[0]->getGeneralizedStress().Size(); }

template <class MAT>
size_t MaterialVector<MAT>::getGeneralizedStrainSize(void) const
  { return (*this)[0]->getGeneralizedStrain().Size(); }

template <class MAT>
m_double MaterialVector<MAT>::getGeneralizedStresses(void) const
  {
    const size_t ncol= getGeneralizedStressSize();
    const size_t nMat= this->size();
    m_double retval(nMat,ncol,0.0);
    for(size_t i= 0;i<nMat;i++)
      {
        const Vector &s= (*this)[i]->getGeneralizedStress();
        for(size_t j= 0;j<ncol;j++)
          retval(i,j)= s(j);
      }
    return retval;
  }

template <class MAT>
m_double MaterialVector<MAT>::getGeneralizedStrains(void) const
  {
    const size_t ncol= getGeneralizedStrainSize();
    const size_t nMat= this->size();
    m_double retval(nMat,ncol,0.0);
    for(size_t i= 0;i<nMat;i++)
      {
        const Vector &s= (*this)[i]->getGeneralizedStrain();
        for(size_t j= 0;j<ncol;j++)
          retval(i,j)= s(j);
      }
    return retval;
  }

template <class MAT>
const Vector &MaterialVector<MAT>::getMeanGeneralizedStress(void) const
  {
    static Vector retval;
    retval= (*this)[0]->getGeneralizedStress();
    const size_t nMat= this->size();
    for(size_t i= 1;i<nMat;i++)
      retval+= (*this)[i]->getGeneralizedStress();
    retval/=nMat;
    return retval;
  }

template <class MAT>
const Vector &MaterialVector<MAT>::getMeanGeneralizedStrain(void) const
  {
    static Vector retval;
    retval= (*this)[0]->getGeneralizedStrain();
    const size_t nMat= this->size();
    for(size_t i= 0;i<nMat;i++)
      retval+= (*this)[i]->getGeneralizedStrain();
    retval/=nMat;
    return retval;
  }

template <class MAT>
double MaterialVector<MAT>::getMeanGeneralizedStrain(const int &defID) const
  {
    double retval= 0.0;
    const Vector &e= getMeanGeneralizedStrain(); //generalized strains vector.
    const ResponseId &code= (*this)[0]->getType();
    const int order= code.Size();
    for(register int i= 0;i<order;i++)
      if(code(i) == defID)
        retval+= e(i);
    return retval;
  }

template <class MAT>
double MaterialVector<MAT>::getMeanGeneralizedStrainByName(const std::string &cod) const
  {
    double retval= 0.0;
    if(cod == "n1")
      retval= this->getMeanGeneralizedStrain(MEMBRANE_RESPONSE_n1);
    else if(cod == "n2")
      retval= this->getMeanGeneralizedStrain(MEMBRANE_RESPONSE_n2);
    else if(cod == "m1") //Flector en torno al eje 1.
      retval= this->getMeanGeneralizedStrain(PLATE_RESPONSE_m1);
    else if(cod == "m2") //Flector en torno al eje 2.
      retval= this->getMeanGeneralizedStrain(PLATE_RESPONSE_m2);
    else if(cod == "q13")
      retval= this->getMeanGeneralizedStrain(PLATE_RESPONSE_q13);
    else if(cod == "q23")
      retval= this->getMeanGeneralizedStrain(PLATE_RESPONSE_q23);
    else if(cod == "m12")
      retval= this->getMeanGeneralizedStrain(PLATE_RESPONSE_m12);
    else if(cod == "n12")
      retval= this->getMeanGeneralizedStrain(MEMBRANE_RESPONSE_n12);
    else
      std::cerr << nombre_clase() << "::" << __FUNCTION__
        << "stress code: '" << cod << " unknown." << std::endl;
    return retval;
  }

template <class MAT>
double MaterialVector<MAT>::getMeanGeneralizedStress(const int &defID) const
  {
    double retval= 0.0;
    const Vector &f= getMeanGeneralizedStress(); //Vector de esfuerzos.
    const ResponseId &code= (*this)[0]->getType();
    const int order= code.Size();
    for(register int i= 0;i<order;i++)
      if(code(i) == defID)
        retval+= f(i);
    return retval;
  }

template <class MAT>
double MaterialVector<MAT>::getMeanGeneralizedStressByName(const std::string &cod) const
  {
    double retval= 0.0;
    if(cod == "n1") //Esfuerzo axil medio por unidad de longitud, paralelo al eje 1.
      retval= this->getMeanGeneralizedStress(MEMBRANE_RESPONSE_n1);
    else if(cod == "n2") //Esfuerzo axil medio por unidad de longitud, paralelo al eje 2.
      retval= this->getMeanGeneralizedStress(MEMBRANE_RESPONSE_n2);
    else if(cod == "n12")
      retval= this->getMeanGeneralizedStress(MEMBRANE_RESPONSE_n12);
    else if(cod == "m1") //Flector medio por unidad de longitud, en torno al eje 1.
      retval= this->getMeanGeneralizedStress(PLATE_RESPONSE_m1);
    else if(cod == "m2") //Flector medio por unidad de longitud, en torno al eje 2.
      retval= this->getMeanGeneralizedStress(PLATE_RESPONSE_m2);
    else if(cod == "m12")
      retval= this->getMeanGeneralizedStress(PLATE_RESPONSE_m12);
    else if(cod == "q13")
      retval= this->getMeanGeneralizedStress(PLATE_RESPONSE_q13);
    else if(cod == "q23")
      retval= this->getMeanGeneralizedStress(PLATE_RESPONSE_q23);
    else
      std::cerr << nombre_clase() << "::" << __FUNCTION__
        << "stress code: '" << cod << " unknown." << std::endl;
    return retval;
  }

template <class MAT>
m_double MaterialVector<MAT>::getGeneralizedStress(const int &defID) const
  {
    const size_t nMat= this->size();
    m_double retval(nMat,1,0.0);
    const ResponseId &code= (*this)[0]->getType();
    const int order= code.Size();
    for(size_t i= 0;i<nMat;i++)
      {
        const Vector &s= (*this)[i]->getGeneralizedStress();
        for(register int j= 0;j<order;j++)
          if(code(j) == defID)
            retval(i,1)+= s(i);
      }
    return retval;
  }

template <class MAT>
m_double MaterialVector<MAT>::getGeneralizedStrain(const int &defID) const
  {
    const size_t nMat= this->size();
    m_double retval(nMat,1,0.0);
    const ResponseId &code= (*this)[0]->getType();
    const int order= code.Size();
    for(size_t i= 0;i<nMat;i++)
      {
        const Vector &s= (*this)[i]->getGeneralizedStrain();
        for(register int j= 0;j<order;j++)
          if(code(j) == defID)
            retval(i,1)+= s(i);
      }
    return retval;
  }

template <class MAT>
void MaterialVector<MAT>::setInitialGeneralizedStrains(const std::vector<Vector> &iS)
  {
    const size_t nMat= this->size();
    const size_t sz= std::min(nMat,iS.size());
    if(iS.size()<nMat)
      std::cerr << nombre_clase() << "::" << __FUNCTION__
            << "; received: "
                << iS.size() << " generalized strain vectors, expected: "
                << nMat << ".\n";
    for(size_t i= 0;i<sz;i++)
      (*this)[i]->setInitialGeneralizedStrain(iS[i]);
  }

template <class MAT>
void MaterialVector<MAT>::addInitialGeneralizedStrains(const std::vector<Vector> &iS)
  {
    const size_t nMat= this->size();
    const size_t sz= std::min(nMat,iS.size());
    if(iS.size()<nMat)
      std::cerr << nombre_clase() << "::" << __FUNCTION__
            << "; received: "
                << iS.size() << " generalized strain vectors, expected: "
                << nMat << ".\n";
    for(size_t i= 0;i<sz;i++)
      (*this)[i]->addInitialGeneralizedStrain(iS[i]);
  }

template <class MAT>
void MaterialVector<MAT>::zeroInitialGeneralizedStrains(void)
  {
    const size_t nMat= this->size();
    for(size_t i= 0;i<nMat;i++)
      (*this)[i]->zeroInitialGeneralizedStrain();
  }

template <class MAT>
XC::DbTagData &MaterialVector<MAT>::getDbTagData(void) const
  {
    static DbTagData retval(2);
    return retval;
  }

template <class MAT>
int MaterialVector<MAT>::sendData(CommParameters &cp)
  {
    int res= 0;
    if(this->empty())
      setDbTagDataPos(0,0);
    else
      {
        setDbTagDataPos(0,1);
        const size_t nMat= this->size();
        DbTagData cpMat(nMat*3);

        for(size_t i= 0;i<nMat;i++)
          res+= cp.sendBrokedPtr((*this)[i],cpMat,BrokedPtrCommMetaData(i,i+nMat,i+2*nMat));
        res+= cpMat.send(getDbTagData(),cp,CommMetaData(1));
      }
    return res;
  }

template <class MAT>
int MaterialVector<MAT>::recvData(const CommParameters &cp)
  {
    const int flag = getDbTagDataPos(0);
    int res= 0;
    if(flag!=0)
      {
        const size_t nMat= this->size();
        DbTagData cpMat(nMat*3);
        res+= cpMat.receive(getDbTagData(),cp,CommMetaData(1));

        for(size_t i= 0;i<nMat;i++)
          {
            const BrokedPtrCommMetaData meta(i,i+nMat,i+2*nMat);
            // Receive the material
            (*this)[i]= cp.getBrokedMaterial((*this)[i],cpMat,meta);
          }
      }
    return res;
  }

template <class MAT>
int MaterialVector<MAT>::sendSelf(CommParameters &cp)
  {
    inicComm(2);
    int res= sendData(cp);
    const int dataTag=getDbTag();
    res+= cp.sendIdData(getDbTagData(),dataTag);
    if(res < 0)
      std::cerr << nombre_clase() << "::" << __FUNCTION__
                << dataTag << " failed to send ID";
    return res;
  }

template <class MAT>
int MaterialVector<MAT>::recvSelf(const CommParameters &cp)
  {
    const int dataTag= this->getDbTag();
    inicComm(2);
    int res= cp.receiveIdData(getDbTagData(),dataTag);
    if(res<0)
      std::cerr << nombre_clase() << "::" << __FUNCTION__
                << dataTag << " failed to receive ID\n";
    else
      res+= recvData(cp);
    return res;
  }

} // end of XC namespace

#endif