CPGNode.h

Go to the documentation of this file.

/*
 * Copyright © 2012, United States Government, as represented by the
 * Administrator of the National Aeronautics and Space Administration.
 * All rights reserved.
 * 
 * The NASA Tensegrity Robotics Toolkit (NTRT) v1 platform is licensed
 * under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0.
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
*/

#ifndef SIMULATOR_SRC_LIB_MODELS_SNAKE_CPGS_CPGNODE
#define SIMULATOR_SRC_LIB_MODELS_SNAKE_CPGS_CPGNODE

#include <algorithm> //for_each
#include <math.h> 
#include <vector>
#include <assert.h>
#include <sstream>

#include "CPGEdge.h"

//Forward Declaration
class CPGEdge; 

class CPGNode
{
                public:
                
                CPGNode(int nodeNum, const std::vector<double> & params);
                ~CPGNode();
                
                void addCoupling(CPGEdge* newEdge);
                
                void addCoupling(               CPGNode* cNode,
                                                                                                const double cWeight,
                                                                                                const double cPhase);
                                                                                                
                void addCoupling(std::vector<CPGEdge*> edgeList);
                
                void updateDTs( double descCom);
                
                double nodeEquation(            double d,
                                                                                                                double c0,
                                                                                                                double c1);
                                                                
                void updateNodeValues (         double newR,
                                                                                                                double newRD,
                                                                                                                double newPhi);
                // out of date since we're using pointers, but still potentially useful
                #if (0)
                std::vector<CPGNode*> getCoupling(){
                                std::vector<CPGNode*> couplingNumbers;
                                return couplingNumbers;
                }
                #endif
                
                const int getNodeIndex() const
                {
                                return m_nodeNumber;
                }
                
                std::string toString(const std::string& prefix = "") const;
                
                double nodeValue;
                double phiValue;
                double phiDotValue;
                double rValue; //Radius
                double rDotValue; //rDot for next update
                double rDoubleDotValue; //Deriviative of RDot
                
                protected:
                
                std::vector<CPGEdge*> couplingList;
                
                const int m_nodeNumber;
                
                const double rConst;
                
                const double frequencyOffset;
                const double frequencyScale;
                
                const double radiusOffset;
                const double radiusScale;
                
                const double dMin;
                const double dMax;
                
};

inline std::ostream&
operator<<(std::ostream& os, const CPGNode& obj)
{
    os << obj.toString() << std::endl;
                return os;
}

#endif // SIMULATOR_SRC_LIB_MODELS_SNAKE_CPGS_CPGNODE