Object.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2015 by Federico Marulli and Alfonso Veropalumbo  *
 *  federico.marulli3@unibo.it                                      *
 *                                                                  *
 *  This program 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 2 of  *
 *  the License, or (at your option) any later version.             *
 *                                                                  *
 *  This program 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, write to the Free      *
 *  Software Foundation, Inc.,                                      *
 *  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.       *
 ********************************************************************/
 
#ifndef __OBJECT__
#define __OBJECT__ 
 
 
// ============================================================================================
 
 
namespace cbl {
 
  namespace catalogue {
    
    enum class ObjectType {
    
      _Random_,
    
      _Mock_,
    
      _Halo_,
    
      _Galaxy_,
    
      _Cluster_,
    
      _Void_,
    
      _HostHalo_,
      
      // chain Mesh cell
      _ChainMeshCell_
    
    };
 
    inline std::vector<std::string> ObjectTypeNames ()
    { return {"Random", "Mock", "Halo", "Galaxy", "Cluster", "Void", "HostHalo", "ChainMeshCell"}; }
 
    inline ObjectType ObjectTypeCast (const int objectTypeIndex)
    { return castFromValue<ObjectType>(objectTypeIndex); }
 
    inline ObjectType ObjectTypeCast (const std::string objectTypeName)
    { return castFromName<ObjectType>(objectTypeName, ObjectTypeNames()); }
 
    inline std::vector<ObjectType> ObjectTypeCast (const std::vector<int> objectTypeIndeces)
    { return castFromValues<ObjectType>(objectTypeIndeces); } 
 
    inline std::vector<ObjectType> ObjectTypeCast (const std::vector<std::string> objectTypeNames)
    { return castFromNames<ObjectType>(objectTypeNames, ObjectTypeNames()); }
 
    class Object {
 
    protected:
      
      double m_xx = cbl::par::defaultDouble;
    
      double m_yy = cbl::par::defaultDouble;
 
      double m_zz = cbl::par::defaultDouble;
 
      double m_ra = cbl::par::defaultDouble; 
 
      double m_dec = cbl::par::defaultDouble;
      
      double m_ra_tile = cbl::par::defaultDouble; 
 
      double m_dec_tile = cbl::par::defaultDouble;  
 
      double m_redshift = cbl::par::defaultDouble;
 
      double m_dc = cbl::par::defaultDouble;
 
      double m_weight = 1.;
      
      long m_region = cbl::par::defaultLong;
 
      int m_ID = cbl::par::defaultInt;
      
      std::string m_field = cbl::par::defaultString;
      
      double m_x_displacement = cbl::par::defaultDouble;
 
      double m_y_displacement = cbl::par::defaultDouble;
      
      double m_z_displacement = cbl::par::defaultDouble;
      
      double m_redshiftMin = cbl::par::defaultDouble;
      
      double m_redshiftMax = cbl::par::defaultDouble;
      
      double m_sn = cbl::par::defaultDouble;
 
    
    public :
    
    
      Object () = default;
      
      Object (const int ID) 
  : m_ID(ID) {}
      
      Object (const comovingCoordinates coord, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble, const double redshiftMin=par::defaultDouble, const double redshiftMax=par::defaultDouble, const double sn=par::defaultDouble) 
    : m_xx(coord.xx), m_yy(coord.yy), m_zz(coord.zz), m_ra(par::defaultDouble), m_dec(par::defaultDouble), m_redshift(par::defaultDouble), m_dc(par::defaultDouble), m_weight(weight), m_region(region), m_ID(ID), m_field(field), m_x_displacement(x_displacement), m_y_displacement(y_displacement), m_z_displacement(z_displacement), m_redshiftMin(redshiftMin), m_redshiftMax(redshiftMax), m_sn(sn) {}
    
      Object (const comovingCoordinates coord, const cosmology::Cosmology &cosm, const double z1_guess=0., const double z2_guess=10., const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble, const double redshiftMin=par::defaultDouble, const double redshiftMax=par::defaultDouble, const double sn=par::defaultDouble) 
    : m_xx(coord.xx), m_yy(coord.yy), m_zz(coord.zz), m_weight(weight), m_region(region), m_ID(ID), m_field(field), m_x_displacement(x_displacement), m_y_displacement(y_displacement), m_z_displacement(z_displacement), m_redshiftMin(redshiftMin), m_redshiftMax(redshiftMax), m_sn(sn)
    {
      cbl::polar_coord(m_xx, m_yy, m_zz, m_ra, m_dec, m_dc);
      m_redshift = cosm.Redshift(m_dc, z1_guess, z2_guess);
    }
 
      Object (const observedCoordinates coord, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble, const double redshiftMin=par::defaultDouble, const double redshiftMax=par::defaultDouble, const double sn=par::defaultDouble) 
    : m_ra(coord.ra), m_dec(coord.dec), m_redshift(coord.redshift), m_dc(par::defaultDouble), m_weight(weight), m_region(region), m_ID(ID), m_field(field), m_x_displacement(x_displacement), m_y_displacement(y_displacement), m_z_displacement(z_displacement), m_redshiftMin(redshiftMin), m_redshiftMax(redshiftMax), m_sn(sn) {}
      
      Object (const observedCoordinates coord, const CoordinateUnits inputUnits, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble, const double redshiftMin=par::defaultDouble, const double redshiftMax=par::defaultDouble, const double sn=par::defaultDouble) 
    : m_ra(radians(coord.ra, inputUnits)), m_dec(radians(coord.dec, inputUnits)), m_redshift(coord.redshift), m_dc(par::defaultDouble), m_weight(weight), m_region(region), m_ID(ID), m_field(field), m_x_displacement(x_displacement), m_y_displacement(y_displacement), m_z_displacement(z_displacement), m_redshiftMin(redshiftMin), m_redshiftMax(redshiftMax), m_sn(sn) {}
      
      Object (const observedCoordinates coord, const cosmology::Cosmology &cosm, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble, const double redshiftMin=par::defaultDouble, const double redshiftMax=par::defaultDouble, const double sn=par::defaultDouble) 
    : m_ra(coord.ra), m_dec(coord.dec), m_redshift(coord.redshift), m_dc(par::defaultDouble), m_weight(weight), m_region(region), m_ID(ID), m_field(field), m_x_displacement(x_displacement), m_y_displacement(y_displacement), m_z_displacement(z_displacement), m_redshiftMin(redshiftMin), m_redshiftMax(redshiftMax), m_sn(sn)
    { 
      m_dc = cosm.D_C(m_redshift); 
      cbl::cartesian_coord(m_ra, m_dec, m_dc, m_xx, m_yy, m_zz);
    }
 
      Object (const observedCoordinates coord, const CoordinateUnits inputUnits, const cosmology::Cosmology &cosm, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble, const double redshiftMin=par::defaultDouble, const double redshiftMax=par::defaultDouble, const double sn=par::defaultDouble) 
    : m_ra(radians(coord.ra, inputUnits)), m_dec(radians(coord.dec, inputUnits)), m_redshift(coord.redshift), m_dc(par::defaultDouble), m_weight(weight), m_region(region), m_ID(ID), m_field(field), m_x_displacement(x_displacement), m_y_displacement(y_displacement), m_z_displacement(z_displacement), m_redshiftMin(redshiftMin), m_redshiftMax(redshiftMax), m_sn(sn)
    { 
      m_dc = cosm.D_C(m_redshift);
      cbl::cartesian_coord(m_ra, m_dec, m_dc, m_xx, m_yy, m_zz);
    }
 
      Object (const double xx, const double yy, const double zz, const double ra, const double dec, const double redshift, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble, const double redshiftMin=par::defaultDouble, const double redshiftMax=par::defaultDouble, const double sn=par::defaultDouble) 
      : m_xx(xx), m_yy(yy), m_zz(zz), m_ra(ra), m_dec(dec), m_redshift(redshift), m_dc(sqrt(xx*xx+yy*yy+zz*zz)), m_weight(weight), m_region(region), m_ID(ID), m_field(field), m_x_displacement(x_displacement), m_y_displacement(y_displacement), m_z_displacement(z_displacement), m_redshiftMin(redshiftMin), m_redshiftMax(redshiftMax), m_sn(sn)
      {}   
 
 
      virtual std::shared_ptr<Object> getShared() {
        return std::make_shared<Object>(*this);
      }
 
      virtual ~Object () = default;
 
 
    
      
      static std::shared_ptr<Object> Create (const ObjectType ObjectType );
 
      static std::shared_ptr<Object> Create (const ObjectType ObjectType, const comovingCoordinates coord, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble);
      
      static std::shared_ptr<Object> Create (const ObjectType ObjectType, const comovingCoordinates coord, const cosmology::Cosmology &cosm, const double z1_guess=0., const double z2_guess=10., const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble);
 
      static std::shared_ptr<Object> Create (const ObjectType ObjectType, const observedCoordinates coord, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble);
 
      static std::shared_ptr<Object> Create (const ObjectType ObjectType, const observedCoordinates coord, const CoordinateUnits inputUnits, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble);
 
      static std::shared_ptr<Object> Create (const ObjectType ObjectType, const observedCoordinates coord, const cosmology::Cosmology &cosm, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble);
 
      static std::shared_ptr<Object> Create (const ObjectType ObjectType, const observedCoordinates coord, const CoordinateUnits inputUnits, const cosmology::Cosmology &cosm, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble);
 
      static std::shared_ptr<Object> Create (const ObjectType ObjectType, const double xx, const double yy, const double zz, const double ra, const double dec, const double redshift, const double weight=1., const long region=par::defaultLong, const int ID=par::defaultInt, const std::string field=par::defaultString, const double x_displacement=par::defaultDouble, const double y_displacement=par::defaultDouble, const double z_displacement=par::defaultDouble);
 
 
      static std::shared_ptr<Object> Create (const int ID=par::defaultInt, const std::vector<unsigned int> part={}, std::vector<std::vector<unsigned int>> nearCells={});
 
    
      
      double xx () const
      { return (cbl::isSet(m_xx)) ? m_xx : ErrorCBL("the m_xx variable is not defined!", "xx", "Object.h"); }
 
      double yy () const
      { return (cbl::isSet(m_yy)) ? m_yy : ErrorCBL("the m_yy variable is not defined!", "yy", "Object.h"); }
 
      double zz () const
      { return (cbl::isSet(m_zz)) ? m_zz : ErrorCBL("the m_zz variable is not defined!", "zz", "Object.h"); }
 
      double dc () const
      { return (cbl::isSet(m_dc)) ? m_dc : ErrorCBL("the m_dc variable is not defined!", "dc", "Object.h"); }
    
      double ra () const
      { return (cbl::isSet(m_ra)) ? m_ra : ErrorCBL("the m_ra variable is not defined!", "ra", "Object.h"); } 
    
      double dec () const
      { return (cbl::isSet(m_dec)) ? m_dec : ErrorCBL("the m_dec variable is not defined!", "dec", "Object.h"); }
      
      double ra_tile () const
      { return (cbl::isSet(m_ra_tile)) ? m_ra_tile : ErrorCBL("the m_ra_tile variable is not defined!", "ra_tile", "Object.h"); } 
    
      double dec_tile () const
      { return (cbl::isSet(m_dec_tile)) ? m_dec_tile : ErrorCBL("the m_dec_tile variable is not defined!", "dec_tile", "Object.h"); }
      
      double sn () const
      { return (cbl::isSet(m_sn)) ? m_sn : ErrorCBL("the m_sn variable is not defined!", "sn", "Object.h"); }
    
      double redshift () const
      { return (cbl::isSet(m_redshift)) ? m_redshift : ErrorCBL("the m_redshift variable is not defined!", "redshift", "Object.h"); }
      
      double redshiftMin () const
      { return (cbl::isSet(m_redshiftMin)) ? m_redshiftMin : ErrorCBL("the m_redshiftMin variable is not defined!", "redshiftMin", "Object.h"); }
      
      double redshiftMax () const
      { return (cbl::isSet(m_redshiftMin)) ? m_redshiftMax : ErrorCBL("the m_redshiftMax variable is not defined!", "redshiftMax", "Object.h"); }
    
      double weight () const
      { return (cbl::isSet(m_weight)) ? m_weight : ErrorCBL("the m_weight variable is not defined!", "weight", "Object.h"); }
 
      long region () const
      { return (cbl::isSet(m_region)) ? m_region : ErrorCBL("the m_region variable is not defined!", "region", "Object.h"); }
 
      int ID () const
      { return (cbl::isSet(m_ID)) ? m_ID : cbl::ErrorCBL("the m_ID variable is not defined!", "ID", "Object.h"); }
      
      std::string field () const
    {
      if (!cbl::isSet(m_field)) ErrorCBL("the m_field variable is not defined!", "field", "Object.h");
      return m_field;
    }
 
      double x_displacement () const
      { return (cbl::isSet(m_x_displacement)) ? m_x_displacement : ErrorCBL("the m_x_displacement variable is not defined!", "x_displacement", "Object.h"); }
 
      double y_displacement () const
      { return (cbl::isSet(m_y_displacement)) ? m_y_displacement : ErrorCBL("the m_y_displacement variable is not defined!", "y_displacement", "Object.h"); }
 
      double z_displacement () const
      { return (cbl::isSet(m_z_displacement)) ? m_z_displacement : ErrorCBL("the m_z_displacement variable is not defined!", "z_displacement", "Object.h"); }
 
      std::vector<double> coords () const
    {
      if (!cbl::isSet(m_xx) || !cbl::isSet(m_yy) || !cbl::isSet(m_zz))
        ErrorCBL("one or more of the m_xx, m_yy, m_zz variables is not defined!", "coords", "Object.h");
      return {m_xx, m_yy, m_zz};
    }
    
      virtual double vx () const
      { return cbl::ErrorCBL("", "vx", "Object.h"); }
    
      virtual double vy () const
      { return cbl::ErrorCBL("", "vy", "Object.h"); }
    
      virtual double vz () const
      { return cbl::ErrorCBL("", "vz", "Object.h"); }
  
      virtual double mass () const
      { return cbl::ErrorCBL("", "mass", "Object.h"); }
      
      virtual double proxyerror () const
      { return cbl::ErrorCBL("", "proxyerror", "Object.h"); }
    
      virtual double magnitude () const
      { return cbl::ErrorCBL("", "magnitude", "Object.h"); }  
      
      virtual double magnitudeU () const
      { return cbl::ErrorCBL("", "magnitudeU", "Object.h"); }  
      
      virtual double magnitudeG () const
      { return cbl::ErrorCBL("", "magnitudeG", "Object.h"); }  
      
      virtual double magnitudeR () const
      { return cbl::ErrorCBL("", "magnitudeR", "Object.h"); }  
      
      virtual double magnitudeI () const
      { return cbl::ErrorCBL("", "magnitudeI", "Object.h"); }  
      
      virtual double odds () const
      { return cbl::ErrorCBL("", "odds", "Object.h"); }
      
      virtual double shear1 () const
      { return cbl::ErrorCBL("", "shear1", "Object.h"); }
      
      virtual double shear2 () const
      { return cbl::ErrorCBL("", "shear2", "Object.h"); }
      
      virtual double lensingWeight () const
      { return cbl::ErrorCBL("", "lensingWeight", "Object.h"); }
      
      virtual double lensingCalib () const
      { return cbl::ErrorCBL("", "lensingCalib", "Object.h"); } 
 
      virtual double SFR () const
      { return cbl::ErrorCBL("", "SFR", "Object.h"); }
 
      virtual double sSFR () const
      { return cbl::ErrorCBL("", "sSFR", "Object.h"); } 
      
      virtual double mass_proxy () const
      { return cbl::ErrorCBL("", "mass_proxy", "Object.h"); }
      
      virtual double mass_proxy_error () const
      { return cbl::ErrorCBL("", "mass_proxy_error", "Object.h"); }
     
      virtual int IDHost () const
      { return cbl::ErrorCBL("", "IDHost", "Object.h"); } 
      
      virtual double galaxyTag () const
      { cbl::ErrorCBL("", "galaxyTag", "Object.h"); return {}; }
 
      virtual double mstar () const
      { return cbl::ErrorCBL("", "mstar", "Object.h"); }
 
      virtual double massinfall () const
      { return cbl::ErrorCBL("", "massinfall", "Object.h"); } 
      
      virtual double bias () const
      { return cbl::ErrorCBL("", "bias", "Object.h"); }  
    
      virtual double generic () const
      { return cbl::ErrorCBL("", "generic", "Object.h"); }  
    
      virtual double radius () const
      { return cbl::ErrorCBL("", "radius", "Object.h"); }
    
      virtual double densityContrast () const
      { return cbl::ErrorCBL("", "densityContrast", "Object.h"); }
    
      virtual double centralDensity () const
      { return cbl::ErrorCBL("", "centralDensity", "Object.h"); }
    
      virtual double mass_estimate () const
      { return cbl::ErrorCBL("", "mass_estimate", "Object.h"); }
    
      virtual double radius_estimate () const
      { return cbl::ErrorCBL("", "radius_estimate", "Object.h"); }
    
      virtual double veldisp_estimate () const
      { return cbl::ErrorCBL("", "veldisp_estimate", "Object.h"); }
    
      virtual double xcm () const
      { return cbl::ErrorCBL("", "xcm", "Object.h"); }
    
      virtual double ycm () const
      { return cbl::ErrorCBL("", "ycm", "Object.h"); }
    
      virtual double zcm () const
      { return cbl::ErrorCBL("", "zcm", "Object.h"); }
    
      virtual double spin_x () const
      { return cbl::ErrorCBL("", "spin_x", "Object.h"); }
    
      virtual double spin_y () const
      { return cbl::ErrorCBL("", "spin_y", "Object.h"); }
    
      virtual double spin_z () const
      { return cbl::ErrorCBL("", "spin_z", "Object.h"); }
    
      virtual double veldisp () const
      { return cbl::ErrorCBL("", "veldisp", "Object.h"); }
    
      virtual double vmax () const
      { return cbl::ErrorCBL("", "vmax", "Object.h"); }
    
      virtual double vmax_rad () const
      { return cbl::ErrorCBL("", "vmax_rad", "Object.h"); }
    
      virtual double tot_mass () const
      { return cbl::ErrorCBL("", "tot_mass", "Object.h"); }
    
      virtual int parent () const { return cbl::ErrorCBL("", "parent", "Object.h"); }
    
      virtual int nsub () const
      { return cbl::ErrorCBL("", "nsub", "Object.h"); }
    
      virtual std::vector<std::shared_ptr<Object>> satellites () const
      { cbl::ErrorCBL("", "satellites", "Object.h"); return {}; }
 
      virtual std::vector<unsigned int> part () const
      { return {}; }
 
      virtual std::vector<std::vector<unsigned int>> nearCells () const  
      { return {}; }
 
    
      
      void set_xx (const double xx)
      { m_xx = xx; }
 
      void set_yy (const double yy)
      { m_yy = yy; }
    
      void set_zz (const double zz)
      { m_zz = zz; }
    
      void set_ra (const double ra, const CoordinateUnits inputUnits=CoordinateUnits::_radians_)
      {
    m_ra = radians(ra, inputUnits);
    if (m_dc>par::defaultDouble) cbl::cartesian_coord(m_ra, m_dec, m_dc, m_xx, m_yy, m_zz);
      }
    
      void set_dec (const double dec, const CoordinateUnits inputUnits=CoordinateUnits::_radians_)
      {
    m_dec = radians(dec, inputUnits);
    if (m_dc>par::defaultDouble) cbl::cartesian_coord(m_ra, m_dec, m_dc, m_xx, m_yy, m_zz);
      }
      
      void set_ra_tile (const double ra, const CoordinateUnits inputUnits=CoordinateUnits::_radians_)
      {
    m_ra_tile = radians(ra, inputUnits);
      }
    
      void set_dec_tile (const double dec, const CoordinateUnits inputUnits=CoordinateUnits::_radians_)
      {
    m_dec_tile = radians(dec, inputUnits);
      }
      
      void set_sn (const double sn)
      { m_sn = sn; }
      
      void set_redshift (const double redshift, const cosmology::Cosmology cosmology, const bool update_coordinates=true)
      {
    m_redshift = redshift;
    if (update_coordinates) {
      m_dc = cosmology.D_C(m_redshift); 
      cbl::cartesian_coord(m_ra, m_dec, m_dc, m_xx, m_yy, m_zz);
    }
      }
      
      void set_redshiftMin (const double redshiftMin)
      { m_redshiftMin = redshiftMin; }
      
      void set_redshiftMax (const double redshiftMax)
      { m_redshiftMax = redshiftMax; }
      
      virtual void set_odds (const double odds)
      { (void)odds; cbl::ErrorCBL("", "set_odds", "Object.h"); }  
      
      virtual void set_shear1 (const double shear1)
      { (void)shear1; cbl::ErrorCBL("", "set_shear1", "Object.h"); } 
      
      virtual void set_shear2 (const double shear2)
      { (void)shear2; cbl::ErrorCBL("", "set_shear2", "Object.h"); } 
      
      virtual void set_lensingWeight (const double lensingWeight)
      { (void)lensingWeight; cbl::ErrorCBL("", "set_lensingWeight", "Object.h"); } 
      
      virtual void set_lensingCalib (const double lensingCalib)
      { (void)lensingCalib; cbl::ErrorCBL("", "set_lensingCalib", "Object.h"); } 
    
      void set_dc (const double dc)
      {
    m_dc = dc;
    cbl::cartesian_coord(m_ra, m_dec, m_dc, m_xx, m_yy, m_zz);
      }
    
      void set_weight (const double weight)
      { m_weight = weight; }
      
      void set_region (const long region)
      { if (region<0) ErrorCBL("Error in Object.h: region must be >0 !", "", "Object.h"); m_region = region; }
      
      void set_ID (const int ID)
      { m_ID = ID; }
      
      void set_field (const std::string field)
      { m_field = field; }
      
      void set_x_displacement (const double x_displacement)
      { m_x_displacement = x_displacement; }
 
      void set_y_displacement (const double y_displacement)
      { m_y_displacement = y_displacement; }
 
      void set_z_displacement (const double z_displacement)
      { m_z_displacement = z_displacement; }
 
      virtual void set_vx (const double vx)
      { (void)vx; cbl::ErrorCBL("", "set_vx", "Object.h"); }
      
      virtual void set_vy (const double vy)
      { (void)vy; cbl::ErrorCBL("", "set_vy", "Object.h"); }
    
      virtual void set_vz (const double vz)
      { (void)vz; cbl::ErrorCBL("", "set_vz", "Object.h"); }
 
      virtual void set_mass (const double mass)
      { (void)mass; cbl::ErrorCBL("", "set_mass", "Object.h"); }
 
      virtual void set_IDHost (const int IDHost)
      { (void)IDHost; cbl::ErrorCBL("", "set_IDHost", "Object.h"); }
 
      virtual void set_galaxyTag (const double galaxyTag)
      { (void)galaxyTag; cbl::ErrorCBL("", "set_galaxyTag", "Object.h"); }
      
      virtual void set_mstar (const double mstar)
      { (void)mstar; cbl::ErrorCBL("", "set_mstar", "Object.h"); }
      
      virtual void set_massinfall (const double massinfall)
      { (void)massinfall; cbl::ErrorCBL("", "set_massinfall", "Object.h"); }
      
      virtual void set_proxyerror (const double value)
      { (void)value; cbl::ErrorCBL("", "set_proxyerror", "Object.h"); }
    
      virtual void set_magnitude (const double magnitude)
      { (void)magnitude; cbl::ErrorCBL("", "set_magnitude", "Object.h"); } 
      
      virtual void set_magnitudeU (const double magnitudeU)
      { (void)magnitudeU; cbl::ErrorCBL("", "set_magnitudeU", "Object.h"); } 
      
      virtual void set_magnitudeG (const double magnitudeG)
      { (void)magnitudeG; cbl::ErrorCBL("", "set_magnitudeG", "Object.h"); } 
      
      virtual void set_magnitudeR (const double magnitudeR)
      { (void)magnitudeR; cbl::ErrorCBL("", "set_magnitudeR", "Object.h"); } 
      
      virtual void set_magnitudeI (const double magnitudeI)
      { (void)magnitudeI; cbl::ErrorCBL("", "set_magnitudeI", "Object.h"); }  
 
      virtual void set_SFR (const double SFR)
      { (void)SFR; cbl::ErrorCBL("", "set_SFR", "Object.h"); }  
    
      virtual void set_sSFR (const double sSFR)
      { (void)sSFR; cbl::ErrorCBL("", "set_sSFR", "Object.h"); }  
      
      virtual void set_mass_proxy (const double mass_proxy)
      { (void)mass_proxy; cbl::ErrorCBL("", "set_mass_proxy", "Object.h"); }
 
      virtual void set_mass_proxy_error (const double mass_proxy_error)
      { (void)mass_proxy_error; cbl::ErrorCBL("", "set_mass_proxy_error", "Object.h"); }
      
      virtual void set_bias (const double bias)
      { (void)bias; cbl::ErrorCBL("", "set_bias", "Object.h"); }  
    
      virtual void set_generic (const double generic)
      { (void)generic; cbl::ErrorCBL("", "set_generic", "Object.h"); }  
    
      virtual void set_radius (const double radius)
      { (void)radius; cbl::ErrorCBL("", "set_radius", "Object.h"); }
    
      virtual void set_densityContrast (const double densityContrast)
      { (void)densityContrast; cbl::ErrorCBL("", "set_densityContrast", "Object.h"); }
    
      virtual void set_centralDensity (const double centralDensity)
      { (void)centralDensity; cbl::ErrorCBL("", "set_centralDensity", "Object.h"); }
    
      virtual void set_mass_estimate (const double mass_estimate)
      { (void)mass_estimate; cbl::ErrorCBL("", "set_mass_estimate", "Object.h"); }
    
      virtual void set_radius_estimate (const double radius_estimate)
      { (void)radius_estimate; cbl::ErrorCBL("", "set_radius_estimate", "Object.h"); }
    
    
      virtual void set_veldisp_estimate (const double veldisp_estimate)
      { (void)veldisp_estimate; cbl::ErrorCBL("", "set_veldisp_estimate", "Object.h"); }
    
      virtual void set_xcm (const double xcm)
      { (void)xcm; cbl::ErrorCBL("", "set_xcm", "Object.h"); }
    
      virtual void set_ycm (const double ycm)
      { (void)ycm; cbl::ErrorCBL("", "set_ycm", "Object.h"); }
    
      virtual void set_zcm (const double zcm)
      { (void)zcm; cbl::ErrorCBL("", "set_zcm", "Object.h"); }
    
      virtual void set_spin_x (const double spin_x)
      { (void)spin_x; cbl::ErrorCBL("", "spin_x", "Object.h"); }
    
      virtual void set_spin_y (const double spin_y)
      { (void)spin_y; cbl::ErrorCBL("", "set_spin_y", "Object.h"); }
    
      virtual void set_spin_z (const double spin_z)
      { (void)spin_z; cbl::ErrorCBL("", "set_spin_z", "Object.h"); }
    
      virtual void set_veldisp (const double veldisp)
      { (void)veldisp; cbl::ErrorCBL("", "set_veldisp", "Object.h"); }
    
      virtual void set_vmax (const double vmax)
      { (void)vmax; cbl::ErrorCBL("", "set_vmax", "Object.h"); }
    
      virtual void set_vmax_rad (const double vmax_rad)
      { (void)vmax_rad; cbl::ErrorCBL("", "set_vmax_rad", "Object.h"); }
    
      virtual void set_tot_mass (const double tot_mass)
      { (void)tot_mass; cbl::ErrorCBL("", "set_tot_mass", "Object.h"); }
    
      virtual void set_parent (const int parent)
      { (void)parent; cbl::ErrorCBL("", "set_parent", "Object.h"); }
      
      virtual void set_nsub (const int nsub)
      { (void)nsub; cbl::ErrorCBL("", "set_nsub", "Object.h"); }
 
      virtual void set_satellite (const std::shared_ptr<Object> satellite)
      { (void)satellite; cbl::ErrorCBL("", "set_satellite", "Object.h"); }
 
      virtual void set_satellites (const std::vector<std::shared_ptr<Object>> satellites)
      { (void)satellites; cbl::ErrorCBL("", "set_satellites", "Object.h"); }
 
      virtual void set_part (const std::vector<unsigned int> part)
      { (void)part; cbl::ErrorCBL("", "set_part", "Object.h"); }
 
      virtual void set_nearCells (const std::vector<std::vector<unsigned int>> nearCells)
      { (void)nearCells; cbl::ErrorCBL("", "set_nearCells", "Object.h"); }
      
 
 
      
      bool isSet_xx () const
      { return (cbl::isSet(m_xx)) ? true : false; }
 
      bool isSet_yy () const
      { return (cbl::isSet(m_yy)) ? true : false; }
    
      bool isSet_zz ()
      { return (cbl::isSet(m_zz)) ? true : false; }
    
      bool isSet_ra ()
      { return (cbl::isSet(m_ra)) ? true : false; }
    
      bool isSet_dec ()
      { return (cbl::isSet(m_dec)) ? true : false; }
      
      bool isSet_ra_tile ()
      { return (cbl::isSet(m_ra_tile)) ? true : false; }
    
      bool isSet_dec_tile ()
      { return (cbl::isSet(m_dec_tile)) ? true : false; }
      
      bool isSet_sn ()
      { return (cbl::isSet(m_sn)) ? true : false; }
      
      bool isSet_redshift ()
      { return (cbl::isSet(m_redshift)) ? true : false; }
      
      bool isSet_redshiftMin ()
      { return (cbl::isSet(m_redshiftMin)) ? true : false;  }
      
      bool isSet_redshiftMax ()
      { return (cbl::isSet(m_redshiftMax)) ? true : false;  }
      
      virtual bool isSet_shear1 ()
      { return cbl::ErrorCBL("", "isSet_shear1", "Object.h"); }  
      
      virtual bool isSet_shear2 ()
      { return cbl::ErrorCBL("", "isSet_shear2", "Object.h"); }  
      
      virtual bool isSet_odds ()
      { return cbl::ErrorCBL("", "isSet_odds", "Object.h"); }  
      
      virtual bool isSet_lensingWeight ()
      { return cbl::ErrorCBL("", "isSet_lensingWeight", "Object.h"); }  
      
      virtual bool isSet_lensingCalib ()
      { return cbl::ErrorCBL("", "isSet_lensingCalib", "Object.h"); }  
     
      bool isSet_dc ()
      { return (cbl::isSet(m_dc)) ? true : false; }
    
      bool isSet_weight ()
      { return (cbl::isSet(m_weight)) ? true : false; }
      
      bool isSet_region ()
      { return (cbl::isSet(m_region)) ? true : false; }
      
      bool isSet_field ()
      { return (cbl::isSet(m_field)) ? true : false; }
      
      bool isSet_x_displacement ()
      { return (cbl::isSet(m_x_displacement)) ? true : false; }
 
      bool isSet_y_displacement ()
      { return (cbl::isSet(m_y_displacement)) ? true : false; }
 
      bool isSet_z_displacement ()
      { return (cbl::isSet(m_z_displacement)) ? true : false; }
 
      virtual bool isSet_vx ()
      { return cbl::ErrorCBL("", "isSet_vx", "Object.h"); }
      
      virtual bool isSet_vy ()
      { return cbl::ErrorCBL("", "isSet_vy", "Object.h"); }
    
      virtual bool isSet_vz ()
      { return cbl::ErrorCBL("", "isSet_vz", "Object.h"); }
 
      virtual bool isSet_mass ()
      { return cbl::ErrorCBL("", "isSet_mass", "Object.h"); }
    
      virtual bool isSet_magnitude ()
      { return cbl::ErrorCBL("", "isSet_magnitude", "Object.h"); }  
      
      virtual bool isSet_magnitudeU ()
      { return cbl::ErrorCBL("", "isSet_magnitudeU", "Object.h"); }  
      
      virtual bool isSet_magnitudeG ()
      { return cbl::ErrorCBL("", "isSet_magnitudeG", "Object.h"); }  
      
      virtual bool isSet_magnitudeR ()
      { return cbl::ErrorCBL("", "isSet_magnitudeR", "Object.h"); }  
      
      virtual bool isSet_magnitudeI ()
      { return cbl::ErrorCBL("", "isSet_magnitudeI", "Object.h"); }  
 
      virtual bool isSet_SFR ()
      { return cbl::ErrorCBL("", "isSet_SFR", "Object.h"); }  
    
      virtual bool isSet_sSFR ()
      { return cbl::ErrorCBL("", "isSet_sSFR", "Object.h"); }  
      
      virtual bool isSet_mass_proxy ()
      { return cbl::ErrorCBL("", "isSet_mass_proxy", "Object.h"); }
 
      virtual bool isSet_mass_proxy_error ()
      { return cbl::ErrorCBL("", "isSet_mass_proxy_error", "Object.h"); }
      
      virtual bool isSet_bias ()
      { return cbl::ErrorCBL("", "isSet_bias", "Object.h"); }  
    
      virtual bool isSet_generic ()
      { return cbl::ErrorCBL("", "isSet_generic", "Object.h"); }  
    
      virtual bool isSet_radius ()
      { return cbl::ErrorCBL("", "isSet_radius", "Object.h"); }
    
      virtual bool isSet_densityContrast ()
      { return cbl::ErrorCBL("", "isSet_densityContrast", "Object.h"); }
    
      virtual bool isSet_centralDensity ()
      { return cbl::ErrorCBL("", "isSet_centralDensity", "Object.h"); }
    
      virtual bool isSet_mass_estimate ()
      { return cbl::ErrorCBL("", "isSet_mass_estimate", "Object.h"); }
    
      virtual bool isSet_radius_estimate ()
      { return cbl::ErrorCBL("", "isSet_radius_estimate", "Object.h"); }
 
      virtual bool isSet_veldisp_estimate ()
      { return cbl::ErrorCBL("", "isSet_veldisp_estimate", "Object.h"); }
    
      virtual bool isSet_xcm ()
      { return cbl::ErrorCBL("", "isSet_xcm", "Object.h"); }
    
      virtual bool isSet_ycm ()
      { return cbl::ErrorCBL("", "isSet_ycm", "Object.h"); }
    
      virtual bool isSet_zcm ()
      { return cbl::ErrorCBL("", "isSet_zcm", "Object.h"); }
    
      virtual bool isSet_spin_x ()
      { return cbl::ErrorCBL("", "isSet_spin_x", "Object.h"); }
    
      virtual bool isSet_spin_y ()
      { return cbl::ErrorCBL("", "isSet_spin_y", "Object.h"); }
    
      virtual bool isSet_spin_z ()
      { return cbl::ErrorCBL("", "isSet_spin_z", "Object.h"); }
    
      virtual bool isSet_veldisp ()
      { return cbl::ErrorCBL("", "isSet_veldisp", "Object.h"); }
    
      virtual bool isSet_vmax ()
      { return cbl::ErrorCBL("", "isSet_vmax", "Object.h"); }
    
      virtual bool isSet_vmax_rad ()
      { return cbl::ErrorCBL("", "isSet_vmax_rad", "Object.h"); }
    
      virtual bool isSet_tot_mass ()
      { return cbl::ErrorCBL("", "isSet_tot_mass", "Object.h"); }
    
      virtual bool isSet_parent ()
      { return cbl::ErrorCBL("", "isSet_parent", "Object.h"); }
    
      virtual bool isSet_nsub ()
      { return cbl::ErrorCBL("", "isSet_nsub", "Object.h"); }
    
      virtual bool isSet_ID ()
      { return cbl::ErrorCBL("", "isSet_ID", "Object.h"); }
 
      virtual bool isSet_IDHost ()
      { return cbl::ErrorCBL("", "isSet_IDHost", "Object.h"); } 
   
      virtual bool isSet_galaxyTag ()
      { return cbl::ErrorCBL("", "isSet_galaxyTag", "Object.h"); }   
 
      virtual bool isSet_mstar ()
      { return cbl::ErrorCBL("", "isSet_mstar", "Object.h"); }
      
      virtual bool isSet_massinfall ()
      { return cbl::ErrorCBL("", "isSet_massinfall", "Object.h"); }
      
      
    };
  }
}
 
#endif