---

sweeper.cc

Go to the documentation of this file.

// SuperMix version 1.0  C++ source file
//
// Copyright (c) 1999 California Institute of Technology.
// All rights reserved.
//
// Redistribution and use in source and binary forms for noncommercial
// purposes are permitted provided that the above copyright notice and
// this paragraph are duplicated in all such forms and that any
// documentation and other materials related to such distribution and
// use acknowledge that the software was developed by California
// Institute of Technology. Redistribution and/or use in source or
// binary forms is not permitted for any commercial purpose. Use of
// this software does not include a permitted use of the Institute's
// name or trademark for any purpose.
//
// DISCLAIMER:
// THIS SOFTWARE AND/OR RELATED MATERIALS ARE PROVIDED "AS-IS" WITHOUT
// WARRANTY OF ANY KIND INCLUDING ANY WARRANTIES OF PERFORMANCE OR
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE OR PURPOSE (AS SET
// FORTH IN UCC 23212-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE
// LICENSED PRODUCT, HOWEVER USED.  IN NO EVENT SHALL CALTECH/JPL BE
// LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING BUT NOT LIMITED TO
// INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, INCLUDING ECONOMIC
// DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, REGARDLESS OF
// WHETHER CALTECH/JPL SHALL BE ADVISED, HAVE REASON TO KNOW, OR IN
// FACT SHALL KNOW OF THE POSSIBILITY.  THE USER BEARS ALL RISK
// RELATING TO QUALITY AND PERFORMANCE OF THE SOFTWARE AND/OR RELATED
// MATERIALS.

// ************************************************************************
//
// sweeper.cc
//
// See sweeper.h for more information.
//
// 7/21/98 J.Z.
//
// 3/20/00:  Added npoints() to sweeper class
// 3/17/00:  Fixed problems with multi-parameter sweeps. FRR
// 4/26/99:  Added initialize member function.  JSW
//
// ************************************************************************

#include "sweeper.h"
#include "error.h"
#include <algorithm>

// Definitions for sweep_parameter
// Note that class sweep_parameter is contained within class sweeper

// no default constructor 

// constructor using startv, stopv, step
sweeper::sweep_parameter::sweep_parameter(real_parameter &rp,
                            double startvp, double stopvp, double stepp) :
  rpr(&rp),
  vecmode(false), 
  startv(0.), 
  stopv(0.), 
  step(0.),
  values(0), 
  num_values(0), 
  index(0),
  wrapped(false) 
{ 
  // need to check parameter values
  if(stepp == 0.) {
    error::warning("Fixing zero step size in sweeper::sweep_parameter() !") ;
    stepp = (stopvp-startvp) ;
  }
  double dtry = (stopvp-startvp)/stepp +1;
  if(dtry < 0.) {
    error::warning(
    "Fixing inconsistent start, stop, and step in sweeper::sweep_parameter()"
                  ) ;
    stepp = -stepp ;
    dtry = -dtry ;
  }
  int nmax = (1 << 31) -1 ;          // assumes at least 32 bit ints
  if(dtry > nmax) {
    error::warning("Fixing very small step in sweeper::sweep_parameter()") ;
    dtry = nmax ;
    stepp = (stopvp-startvp)/(nmax-1) ;
  }
  // All is OK now, so set values
  startv = startvp ;
  stopv = stopvp ;
  step = stepp ;
  num_values = (int) dtry ;
}

// constructor using C-style array of values
sweeper::sweep_parameter::sweep_parameter(real_parameter &rp,
                                          double *valp, int nump) :
  rpr(&rp),
  vecmode(true), 
  startv(0.), 
  stopv(0.), 
  step(0.),
  values(0), 
  num_values(0), 
  index(0),
  wrapped(true) 
{
  if(nump <= 0) {
    error::warning(
    "sweeper::sweep_parameter() -- number of data values in array is <= 0 !"
                  );
  }
  else {
    values.resize(nump) ;    // make enough room
    std::copy(valp, valp+nump, values.begin()) ; // copy into the vector<>
    num_values = values.size() ; // lets ask the vector how many it has
    wrapped = false ;
  }
}

// constructor using SuperMix real_vector
sweeper::sweep_parameter::sweep_parameter(real_parameter &rp,
                                          const real_vector & rvec):
  rpr(&rp),
  vecmode(true), 
  startv(0.), 
  stopv(0.), 
  step(0.),
  values(0), 
  num_values(0), 
  index(0),
  wrapped(true) 
{
  int nump = rvec.maxindex() - rvec.minindex() +1 ;
  if(nump <= 0) {
    error::warning(
    "sweeper::sweep_parameter() -- number of data values in array is <= 0 !"
                  );
  }
  else {
    values.resize(nump) ;    // make enough room
    int imin = rvec.minindex() ;
    for(int i = 0; i < nump; i++)  // copy the vector
      values[i] = rvec.read(i+imin) ;
    num_values = values.size() ; // lets ask the vector how many it has
    wrapped = false ;
  }
}

// constructor using STL vector<double> array
sweeper::sweep_parameter::sweep_parameter(real_parameter &rp,
                                          const std::vector<double> & val) :
  rpr(&rp),
  vecmode(true), 
  startv(0.), 
  stopv(0.), 
  step(0.),
  values(val), 
  num_values(val.size()), 
  index(0),
  wrapped(false) 
{
  if(num_values == 0) {
    wrapped = true ;
  }
}

// increment operator
// define postfix form of increment only 
// see Stroustrup 11.11

sweeper::sweep_parameter &
sweeper::sweep_parameter::operator ++(int)
{
  if(num_values <=0) {
    index = 0 ;
    wrapped = true ;
  }
  else {
    wrapped = false ;
    index++ ;
    if(index >= num_values) {
      wrapped = true ;
      index = 0 ;
    }
  }
  *rpr = getval() ; // set the value of the actual parameter
  return(*this) ;
}


// makes sure parameter has the proper value without incrementing
sweeper::sweep_parameter &
sweeper::sweep_parameter::touch()
{
  if(index < num_values)
    *rpr = getval() ; // set the value of the parameter
  return(*this) ;
}

// reset() the index

void sweeper::sweep_parameter::reset()
{
  index = 0 ;
  wrapped = false ;
  if(num_values <=0) {
    wrapped = true ;
  }  
  *rpr = getval() ; // set the value of the actual parameter
  return ;
}

// This function returns the current value of the sweep_parameter

double sweeper::sweep_parameter::getval() const
{
  double result ;
  if(vecmode) {
    result = values[index] ;
  }
  else {
    result = startv + index*step ;
  }
  return(result) ;
}

//**************************************************************************
// Now follow the definitions for class sweeper proper.

sweeper::sweeper() :
  parms(),  // creates an empty list
  alldone(false),
  num_values(1)
{ }

void sweeper::sweep(real_parameter & rp,
                    double startv, double stopv, double step)
{
  parms.push_back(sweep_parameter(rp, startv, stopv, step)) ;
  // now the last element of the list has this latest sweep
  int n = parms.rbegin()->npoints();
  if(n > 1) num_values *= n;
}

void sweeper::sweep(real_parameter & rp, double *valp, int nump)
{
  parms.push_back(sweep_parameter(rp, valp, nump)) ;
  // now the last element of the list has this latest sweep
  int n = parms.rbegin()->npoints();
  if(n > 1) num_values *= n;
}

void sweeper::sweep(real_parameter & rp, const real_vector & rvec)
{
  parms.push_back(sweep_parameter(rp, rvec)) ;
  // now the last element of the list has this latest sweep
  int n = parms.rbegin()->npoints();
  if(n > 1) num_values *= n;
}

void sweeper::sweep(real_parameter & rp, const std::vector<double> & val)
{
  parms.push_back(sweep_parameter(rp, val)) ;
  // now the last element of the list has this latest sweep
  int n = parms.rbegin()->npoints();
  if(n > 1) num_values *= n;
}

void sweeper::initialize(real_parameter & rp, double value)
{
  parms.push_front(sweep_parameter(rp, std::vector<double>(1,value))) ;
}

// define postfix form of increment only 
// see Stroustrup 11.11
sweeper & sweeper::operator ++(int i)
{
  std::list<sweeper::sweep_parameter>::iterator ipar = parms.begin() ;
  if(!alldone) {
    bool done = false ;  // done goes true when no more incrementing needed
    while(ipar != parms.end() && !done) {
      (*ipar)++ ;   // postfix increment this parameter
      if(ipar->check_wrap() == false) // this parameter didn't wrap
        done = true ;
      ipar++ ;      // go on to next parameter
    }
    while(ipar != parms.end()) (ipar++)->touch();  // set without incrementing
    if(!done)   // all parameters wrapped this time
      alldone = true ;                 // so we're done sweeping

    // call the setup function now that all parameters are set:
    setup();
  }
  else {
    error::warning(
    "cannot increment sweeper object -- the sweep is finished");
  }
    return(*this) ;
}

void sweeper::reset()
{
  alldone = false ;
  // need to reset all parameters in our list
  for(std::list<sweep_parameter>::iterator ipar = parms.begin() ;
      ipar != parms.end() ; ipar++) {
    ipar->reset() ;
  }

  // call the setup function now that all parameters are set:
  setup();
}

---

Please direct comments and corrections to supermix@submm.caltech.edu
Go to the supermix home page
Generated by 1.2.7