コード例 #1
0
ファイル: paz.C プロジェクト: SkyTian13/psrchive
void paz::setup ()
{
  if (!killfile.empty ())
  {
    FILE *fptr = fopen (killfile.c_str (), "r");

    if (!fptr)
      throw Error (FailedSys, "paz::setup", "fopen " + killfile);

    char *buffer = new char[4096];
    while (fgets (buffer, 4096, fptr))
    {
      char* key = strtok (buffer, whitespace);
      while (key)
      {
	chans_to_zero.push_back (fromstring<unsigned>(key));
	key = strtok (NULL, whitespace);
      }
    }
  }

  zero_channels = chans_to_zero.size()
    || freqs_to_zero.size() || freq_ranges_to_zero.size();

  bool zero_subints = subs_to_zero.size ();

  if (zero_intersection && !(zero_channels && zero_subints))
    throw Error (InvalidState, "paz::setup",
		 "must use -I with both -s|S|k *and* -w|W");
  
  if (mow_all_subints || subints_to_mow.size())
    mower = new Pulsar::LawnMower;
  
  if (median_zap || median_zap_bybin || median_zap_window)
  {
    median_zapper = new Pulsar::ChannelZapMedian;
    median_zapper->set_bybin (median_zap_bybin);
    median_zapper->set_paz_report (true);

    if (median_zap_window)
      median_zapper->set_window_size (median_zap_window);
  }

  if (edge_zap_percent < 0.0 || edge_zap_percent >= 100.0)
    throw Error (InvalidState, "paz::setup",
		 "invalid parameter to option -E");

  if (!std_filename.empty())
  {
    Reference::To<Pulsar::Archive> data = Pulsar::Archive::load (std_filename);
    data->pscrunch ();
    data->fscrunch ();
    data->tscrunch ();
    thestd = data->get_Profile (0, 0, 0);
    
    standard_snr.set_standard (thestd);
    Pulsar::Profile::snr_strategy.get_value().set (&standard_snr,
						   &Pulsar::StandardSNR::get_snr);
  }
}
コード例 #2
0
ファイル: psrpca.C プロジェクト: lbaehren/lofarsoft
void psrpca::setup ()
{
  arrival->set_shift_estimator ( new PhaseGradShift );
  try
  {
    std_archive->fscrunch();
    std_archive->pscrunch();
    arrival->set_standard ( std_archive );
  } catch (Error& error)
  {
    cerr << error << endl;
    cerr << "psrpca::setup setting standard failed" << endl;
    exit ( -1 );
  }
}
コード例 #3
0
ファイル: pazi.C プロジェクト: kernsuite-debian/psrchive
/**
 * Zap a specified range of bins by substituting their values with the
 * baseline mean for each profile.
 */
void zap_bins(Pulsar::Archive* arch, Pulsar::Archive* old_arch,
    const unsigned s, const unsigned start_bin, const unsigned end_bin)
{
  const unsigned npol  = old_arch->get_npol();
  const unsigned nchan = old_arch->get_nchan();

  // Get the baseline region from what is displayed on screen (pscrunched
  // and fscrunched integration).
  Reference::To<Pulsar::Archive> copy = old_arch->clone();
  copy->pscrunch();
  copy->fscrunch();

  Reference::To<Pulsar::PhaseWeight> baseline_weights =
    copy->get_Profile(s,0,0)->baseline();

  vector<float> weights;
  baseline_weights->get_weights(weights);

  for (unsigned ipol = 0; ipol < npol; ++ipol) {
    for (unsigned ichan = 0; ichan < nchan; ++ichan) {
      // Apply the baseline region to each profile and get the mean.
      baseline_weights->set_Profile(old_arch->get_Profile(s,ipol,ichan));
      const double baseline_mean = baseline_weights->get_mean().get_value();
      float* bins = old_arch->get_Profile(s,ipol,ichan)->get_amps();

      // Set all the bins between start_bin and end_bin to the mean of the
      // baseline.
      for (unsigned ibin = start_bin; ibin <= end_bin; ++ibin) {
        bins[ibin] = baseline_mean;
      }
    }
  }

  *arch = *old_arch;
  arch->set_dispersion_measure(0);
  arch->pscrunch();
  arch->fscrunch();
  arch->remove_baseline();
}
コード例 #4
0
ファイル: pam.C プロジェクト: lbaehren/lofarsoft
int main (int argc, char *argv[]) try {
  
    bool verbose = false;
    char* metafile = 0;
 
    string ulpath;

    bool save = false;
    string ext;
  
    bool tscr = false;
    int tscr_fac = 0;

    bool fscr = false;
    int fscr_fac = 0;

    bool bscr = false;
    int bscr_fac = 0;

    bool newdm = false;
    double dm = 0.0;

    bool scattered_power_correction = false;

    bool defaraday = false;

    bool newrm = false;
    double rm = 0.0;

    bool reset_weights = false;
    float new_weight = 1.0;

    float smear_dc = 0.0;

    bool rotate = false;
    double rphase = 0.0;

    bool dedisperse = false;
    bool dededisperse = false;

    bool pscr = false;

    bool invint = false;

    bool stokesify = false;
    bool unstokesify = false;

    bool flipsb = false;
    bool flip_freq = false;
    double flip_freq_mhz = 0.0;

    Pulsar::Parameters* new_eph = 0;

    string command = "pam";

    char* archive_class = 0;

    int new_nchn = 0;
    int new_nsub = 0;
    int new_nbin = 0;

    float tsub = 0.0;

    bool circ = false;
    bool lin = false;

    unsigned ronsub = 0;
    bool cbppo = false;
    bool cbpao = false;
    bool cblpo = false;
    bool cblao = false;

    int subint_extract_start = -1;
    int subint_extract_end = -1;

    bool new_cfreq = false;
    double new_fr = 0.0;
    Signal::Source new_type = Signal::Unknown;
    string instrument;
    bool reverse_freqs = false;
    string site;
    string name;
    float mult = -1.0;
    double new_folding_period = -1.0;

    bool update_dm_from_eph = false;
    double aux_rm = 0.0;

    Reference::To<Pulsar::IntegrationOrder> myio;
    Reference::To<Pulsar::Receiver> install_receiver;

    Pulsar::ReflectStokes reflections;

    int c = 0;

    const int TYPE = 1208;
    const int INST = 1209;
    const int REVERSE_FREQS = 1210;
    const int SITE = 1211;
    const int NAME = 1212;
    const int DD   = 1213;
    const int RR   = 1214;
    const int SPC  = 1215;
    const int RM   = 1216;
    const int MULT = 1218;
    const int PERIOD=1219;
    const int SS   = 1220;
    const int FLIP = 1221;
    const int UPDATE_DM = 1222;
    const int AUX_RM = 1223;

    while (1) {

      int options_index = 0;

      static struct option long_options[] = {
	{"setnchn",    1, 0, 200},
	{"setnsub",    1, 0, 201},
	{"setnbin",    1, 0, 202},
	{"binphsperi", 1, 0, 203},
	{"binphsasc",  1, 0, 204},
	{"binlngperi", 1, 0, 205},
	{"binlngasc",  1, 0, 206},
	{"receiver",   1, 0, 207},
	{"settsub",    1, 0, 208},
	{"type",       1, 0, TYPE},
	{"inst",       1, 0, INST},
	{"reverse_freqs",no_argument,0,REVERSE_FREQS},
	{"flip",       1 ,0, FLIP},
	{"site",       1, 0, SITE},
	{"name",       1, 0, NAME},
	{"DD",         no_argument,      0,DD},
	{"RR",         no_argument,      0,RR},
	{"RM",         required_argument,0,RM},
	{"spc",        no_argument,      0,SPC},
	{"mult",       required_argument,0,MULT},
	{"period",     required_argument,0,PERIOD},
	{"SS",         no_argument,      0,SS},
	{"update_dm",   no_argument,      0,UPDATE_DM},
	{"aux_rm",    required_argument,0,AUX_RM},
	{0, 0, 0, 0}
      };

      c = getopt_long(argc, argv, "hqvViM:mn:a:e:E:TFpIt:f:b:d:o:s:r:u:w:DSBLCx:R:",
		      long_options, &options_index);

      if (c == -1)
	break;

      switch (c) {
      case 'h':
	usage();
	return (0);
	break;
      case 'q':
	Pulsar::Archive::set_verbosity(0);
	break;
      case 'v':
	verbose = true;
	Pulsar::Archive::set_verbosity(2);
	break;
      case 'V':
	verbose = true;
	Pulsar::Archive::set_verbosity(3);
	break;
      case 'i':
	cout << "$Id: pam.C,v 1.101 2010/10/05 23:59:50 jonathan_khoo Exp $" << endl;
	return 0;
      case 'm':
	save = true;
	break;
      case 'M':
        metafile = optarg;
        break;
      case 'L':
	lin = true;
	break;
      case 'C':
	circ = true;
	break;
      case 'a':
	archive_class = optarg;
	break;
      case 'e':
	ext = optarg;
	if( !ext.empty() )
	  save = true;
	break;
      case 'E':

	try {
	  new_eph = factory<Pulsar::Parameters> (optarg);
	}
	catch (Error& error) {
	  cerr << "Could not load new ephemeris from " << optarg << endl;
	  return -1;
	}

	command += " -E";
	break;
      case 'T':
	tscr = true;
	command += " -T";
	break;
      case 'F':
	fscr = true;
	command += " -F";
	break;
      case 'p':
	pscr = true;
	command += " -p";
	break;
      case 'I':
	invint = true;
	pscr = false;
	command += " -I";
	break;
      case 'f':
	fscr = true;
	if (sscanf(optarg, "%d", &fscr_fac) != 1) {
	  cout << "That is not a valid fscrunch factor" << endl;
	  return -1;
	}
	command += " -f ";
	command += optarg;
	break;
	
      case 'n':

	reflections.add_reflection( optarg[0] );

	command += " -n ";
	command += optarg;
	break;

      case 'o':
	new_cfreq = true;
	if (sscanf(optarg, "%lf", &new_fr) != 1) {
	  cout << "That is not a valid centre frequency" << endl;
	  return -1;
	}
	command += " -o ";
	command += optarg;
	break;
      case 't':
	tscr = true;
	if (sscanf(optarg, "%d", &tscr_fac) != 1) {
	  cout << "That is not a valid tscrunch factor" << endl;
	  return -1;
	}
	command += " -t ";
	command += optarg;
	break;
      case 'b':
	bscr = true;
	if (sscanf(optarg, "%d", &bscr_fac) != 1) {
	  cout << "That is not a valid bscrunch factor" << endl;
	  return -1;
	}
	if (bscr_fac <= 0) {
	  cout << "That is not a valid bscrunch factor" << endl;
	  return -1;
	}
	command += " -b ";
	command += optarg;
	break;
      case 'd':
	newdm = true;
	if (sscanf(optarg, "%lf", &dm) != 1) {
	  cout << "That is not a valid dispersion measure" << endl;
	  return -1;
	}
	command += " -d ";
	command += optarg;
	break;
      case 'D':
	dedisperse = true;
	command += " -D ";
	break;
      case 'R':
	if (sscanf(optarg, "%lf", &rm) != 1) {
	  cout << "That is not a valid rotation measure" << endl;
	  return -1;
	}
	newrm = true;
	defaraday = true;
	command += " -R ";
	command += optarg;
	break;
      case 's':
	if (sscanf(optarg, "%f", &smear_dc) != 1) {
	  cout << "That is not a valid smearing duty cycle" << endl;
	  return -1;
	}
	command += " -s ";
	command += optarg;
	break;
      case 'r':
	rotate = true;
	if (sscanf(optarg, "%lf", &rphase) != 1) {
	  cout << "That is not a valid rotation phase" << endl;
	  return -1;
	}
	if (rphase <= -1.0 || rphase >= 1.0) {
	  cout << "That is not a valid rotation phase" << endl;
	  return -1;
	}
	command += " -r ";
	command += optarg;
	break;
      case 'u':
	ulpath = optarg;
	if( !ulpath.empty() )
	{
	  save = true;
	  if (ulpath.substr(ulpath.length()-1,1) != "/")
	    ulpath += "/";
	}
	break;
      case 'w':
	reset_weights = true;
	if (sscanf(optarg, "%f", &new_weight) != 1) {
	  cout << "That is not a valid weight" << endl;
	  return -1;
	}
	command += " -w ";
	command += optarg;
	break;
      case 'S':
	stokesify = true;
	break;
      case SS:
        unstokesify = true;
        break;
      case 'B':
	flipsb = true;
	break;
      case 'x' :
	if (sscanf(optarg, "%d %d", 
		   &subint_extract_start, &subint_extract_end) !=2 ) {
	  cout << "That is not a valid subint range" << endl;
	  return -1;
	}
	subint_extract_end++;
	break;
      case 200:
	fscr = true;
	if (sscanf(optarg, "%d", &new_nchn) != 1) {
	  cout << "That is not a valid number of channels" << endl;
	  return -1;
	}
	if (new_nchn <= 0) {
	  cout << "That is not a valid number of channels" << endl;
	  return -1;
	}
	command += " --setnchn ";
	command += optarg;
	break;
      case 201:
	tscr = true;
	if (sscanf(optarg, "%d", &new_nsub) != 1) {
	  cout << "That is not a valid number of subints" << endl;
	  return -1;
	}
	if (new_nsub <= 0) {
	  cout << "That is not a valid number of subints" << endl;
	  return -1;
	}
	command += " --setnsub ";
	command += optarg;
	break;
      case 202:
	bscr = true;
	if (sscanf(optarg, "%d", &new_nbin) != 1) {
	  cout << "That is not a valid number of bins" << endl;
	  return -1;
	}
	if (new_nbin <= 0) {
	  cout << "That is not a valid number of bins" << endl;
	  return -1;
	}
	command += " --setnbin ";
	command += optarg;
	break;
      case 203: {
	if (cbpao || cblpo || cblao) {
	  cerr << "You can only specify one re-ordering scheme!"
	       << endl;
	  return -1;
	}
	if (sscanf(optarg, "%ud", &ronsub) != 1) {
	  cerr << "Invalid nsub given" << endl;
	  return -1;
	}
	cbppo = true;
	break;
      } 
      case 204: {
	if (cbppo || cblpo || cblao) {
	  cerr << "You can only specify one re-ordering scheme!"
	       << endl;
	  return -1;
	}
	if (sscanf(optarg, "%ud", &ronsub) != 1) {
	  cerr << "Invalid nsub given" << endl;
	  return -1;
	}
	cbpao = true;
	break;
      }      
      case 205: {
	if (cblao || cbppo || cbpao) {
	  cerr << "You can only specify one re-ordering scheme!"
	       << endl;
	  return -1;
	}
	if (sscanf(optarg, "%ud", &ronsub) != 1) {
	  cerr << "Invalid nsub given" << endl;
	  return -1;
	}
	cblpo = true;
	break;
      } 
      case 206: {
	if (cblpo || cbppo || cbpao) {
	  cerr << "You can only specify one re-ordering scheme!"
	       << endl;
	  return -1;
	}
	if (sscanf(optarg, "%ud", &ronsub) != 1) {
	  cerr << "Invalid nsub given" << endl;
	  return -1;
	}
	cblao = true;
	break;
      }

      case 207: try {
	install_receiver = Pulsar::Receiver::load (optarg);
	break;
      }
      catch (Error& error) {
	cerr << "pam: Error loading Receiver from " << optarg << endl
	     << error.get_message() << endl;
	return -1;
      }

      case 208: {
	if (sscanf(optarg, "%f", &tsub) != 1) {
	  cerr << "Invalid tsub given" << endl;
	  return -1;
	}
	tscr = true;
	break;
      }

      case TYPE:
	{
	  string s = optarg;
	  if(s=="Pulsar")     new_type = Signal::Pulsar;
	  else if(s=="PolnCal")    new_type = Signal::PolnCal;
	  else if(s=="FluxCalOn")  new_type = Signal::FluxCalOn;
	  else if(s=="FluxCalOff") new_type = Signal::FluxCalOff;
	  else if(s=="Calibrator") new_type = Signal::Calibrator;
	  else{
	    fprintf(stderr,"Unrecognised argument to --type: '%s'\n",optarg);
	    exit(-1);
	  }
	  command += " --type " + s;
	}
	break;

      case INST: instrument = optarg; break;

      case REVERSE_FREQS: reverse_freqs = true; break;

      case SITE: site = optarg; break;

      case NAME: name = optarg; break;

      case DD: dededisperse = true; break;

      case RM:
        aux_rm = fromstring<double>(optarg);
        newrm = true;
        command += " --RM ";
        command += optarg;
        break;

      case SPC: scattered_power_correction = true; break;
	
      case MULT: mult = atof(optarg); break;

      case PERIOD: new_folding_period = fromstring<double>(optarg); break;

      case FLIP: flip_freq = true; flip_freq_mhz = atof(optarg); break;

      case UPDATE_DM: update_dm_from_eph = true; break;

      case AUX_RM:
        aux_rm = fromstring<double>(optarg);
        command += " --aux_rm ";
        command += optarg;
        break;

      default:
	cout << "Unrecognised option" << endl;
      }
    }

   if (verbose)
     cerr << "pam: parsing filenames" << endl;
 
   vector <string> filenames;

    if (metafile)
      stringfload (&filenames, metafile);
    else
      for (int ai=optind; ai<argc; ai++)
        dirglob (&filenames, argv[ai]);
 
    if (filenames.empty())
    {
      cerr << "pam: no filenames were specified" << endl;
      exit(-1);
    } 
  
    Reference::To<Pulsar::Archive> arch;

    if (!save)
    {
      cout << "Changes will not be saved. Use -m, -u or -e to write results to disk"
	   << endl;
    }

    if (stokesify && unstokesify)
    {
      cerr << "pam: Both -S and --SS options were given.  Poln state will not be changed!" << endl;
      stokesify = false;
      unstokesify = false;
    }

    int flip_option_count=0;
    if (flipsb) flip_option_count++;
    if (flip_freq) flip_option_count++;
    if (reverse_freqs) flip_option_count++;
    if (flip_option_count > 1) {
      cerr << "pam: More than one band-flip option was given, exiting." << endl;
      exit(-1);
    }

    for (unsigned i = 0; i < filenames.size(); i++) try
    {
      if (verbose)
	cerr << "Loading " << filenames[i] << endl;
      
      arch = Pulsar::Archive::load(filenames[i]);

      if( mult > 0.0 ){
	for( unsigned isub=0; isub<arch->get_nsubint();isub++)
	  for( unsigned ichan=0; ichan<arch->get_nchan();ichan++)
	    for( unsigned ipol=0; ipol<arch->get_npol();ipol++)
	      arch->get_Profile(isub,ipol,ichan)->scale( mult );
      }

      if( new_folding_period > 0.0 ){
	Pulsar::counter_drift( arch, new_folding_period, 0.0);
	for( unsigned isub=0; isub<arch->get_nsubint();isub++)
	  arch->get_Integration(isub)->set_folding_period( new_folding_period );
      }

      if (install_receiver) {
	if (verbose)
	  cerr << "pam: Installing receiver: " << install_receiver->get_name()
	       << " in archive" << endl;

	arch->add_extension (install_receiver);
      }

      if (lin || circ) {
	Pulsar::Receiver* receiver = arch->get<Pulsar::Receiver>();

	if (!receiver)
	  cerr << "No Receiver Extension in " << filenames[i] << endl;
	else {
	  if (lin) {
	    receiver->set_basis (Signal::Linear);
	    cout << "Feed basis set to Linear" << endl;
	  }

	  if (circ) {
	    receiver->set_basis (Signal::Circular);
	    cout << "Feed basis set to Circular" << endl;
	  }
	}
      }

      reflections.transform( arch );

      if (new_cfreq)
      {
	double nc = arch->get_nchan();
	double bw = arch->get_bandwidth();
	double cw = bw / nc;

	double fr = new_fr - (bw / 2.0) + (cw / 2.0);
	
	for (unsigned i = 0; i < arch->get_nsubint(); i++) {
	  for (unsigned j = 0; j < arch->get_nchan(); j++) {
	    arch->get_Integration(i)->set_centre_frequency(j,(fr + (j*cw)));
	  }
	}
	
	arch->set_centre_frequency(new_fr);
      }

      if( new_type != Signal::Unknown )
	arch->set_type( new_type );

      if( instrument != string() ){
	Pulsar::Backend* b = arch->get<Pulsar::Backend>();
	if( !b )
	  fprintf(stderr,"Could not change instrument name- archive does not have Backend extension\n");
	else
	  b->set_name(instrument);
      }

      if( site != string() )
	arch->set_telescope( site );

      if( name != string() )
	arch->set_source( name );

      if (new_eph) try
      {
        arch->set_ephemeris(new_eph);

        if (update_dm_from_eph) {
          update_dm(arch);
        }
      }
      catch (Error& error)
      {
	cerr << "Error while installing new ephemeris: " 
	     << error.get_message() << endl;
        continue;
      }

      if (flipsb) {
	for (unsigned i = 0; i < arch->get_nsubint(); i++) {
	  vector<double> labels;
	  labels.resize(arch->get_nchan());
	  for (unsigned j = 0; j < arch->get_nchan(); j++) {
	    labels[j] = arch->get_Integration(i)->get_centre_frequency(j);
	  }
	  for (unsigned j = 0; j < arch->get_nchan(); j++) {
	    double new_frequency = labels[labels.size()-1-j];
	    arch->get_Integration(i)->set_centre_frequency(j,new_frequency);
	  }
	}
	arch->set_bandwidth(-1.0 * arch->get_bandwidth());
      }

      if (flip_freq) {
        for (unsigned isub = 0; isub < arch->get_nsubint(); isub++) {
          Reference::To<Pulsar::Integration> 
            subint = arch->get_Integration(isub);
          for (unsigned ichan = 0; ichan < arch->get_nchan(); ichan++) {
            double new_freq = flip_freq_mhz 
              - (subint->get_centre_frequency(ichan) - flip_freq_mhz);
            subint->set_centre_frequency(ichan, new_freq);
          }
        }
        arch->set_bandwidth(-1.0 * arch->get_bandwidth());
      }

      if( reverse_freqs ) {
	// Of course it would be nice to do this with pointers.... but oh well I guess copying will have to do HSK 27/8/04

	unsigned nchan = arch->get_nchan();

	for( unsigned isub=0; isub<arch->get_nsubint(); isub++){
	  for( unsigned ipol =0; ipol<arch->get_npol(); ipol++){
	    for( unsigned ichan=0; ichan<nchan/2; ichan++){
	      Reference::To<Pulsar::Profile> lo = arch->get_Profile(isub,ipol,ichan);	      
	      Reference::To<Pulsar::Profile> tmp = lo->clone();

	      Reference::To<Pulsar::Profile> hi = arch->get_Profile(isub,ipol,nchan-1-ichan);

	      lo->operator=(*hi);
	      hi->operator=(*tmp);
	    }
	  }
	}
	arch->set_bandwidth( -1.0 * arch->get_bandwidth() );
      }

      if (reset_weights) {
	arch->uniform_weight(new_weight);
	if (verbose)
	  cout << "All profile weights set to " << new_weight << endl;
      }
      
      if (rotate)
	arch->rotate_phase (rphase);

      if (scattered_power_correction) {

	Pulsar::ScatteredPowerCorrection spc;
	if (arch->get_state() == Signal::Stokes)
	  arch->convert_state(Signal::Coherence);

	spc.correct (arch);

      }

      if (newdm)
      {
	arch->set_dispersion_measure(dm);
	if (verbose)
	  cout << "Archive dispersion measure set to " << dm << endl;

	if (arch->get_dedispersed())
        {
	  arch->dedisperse();

	  if (verbose)
	    cout << "Archive re-dedipsersed" << endl;
        }
      }

      if (dedisperse)
      {
	arch->dedisperse();
	if (verbose)
	  cout << "Archive dedipsersed" << endl;
      }

      if (dededisperse)
      {
	Pulsar::Dispersion correction;
	correction.revert (arch);
      }

      if (stokesify) {
	if (arch->get_npol() != 4)
	  throw Error(InvalidState, "Convert to Stokes",
		      "Not enough polarisation information");
	arch->convert_state(Signal::Stokes);
	if (verbose)
	  cout << "Archive converted to Stokes parameters" << endl;
      }

      if (unstokesify) {
	if (arch->get_npol() != 4)
	  throw Error(InvalidState, "Convert to coherence",
		      "Not enough polarisation information");
	arch->convert_state(Signal::Coherence);
	if (verbose)
	  cout << "Archive converted to coherence parameters" << endl;
      }

      if (cbppo) {
	myio = new Pulsar::PeriastronOrder();
	arch->add_extension(myio);
	myio->organise(arch, ronsub);
      }
      
      if (cbpao) {
	myio = new Pulsar::BinaryPhaseOrder();
	arch->add_extension(myio);
	myio->organise(arch, ronsub);
      }
      
      if (cblpo) {
	myio = new Pulsar::BinLngPeriOrder();
	arch->add_extension(myio);
	myio->organise(arch, ronsub);
      }
      
      if (cblao) {
	myio = new Pulsar::BinLngAscOrder();
	arch->add_extension(myio);
	myio->organise(arch, ronsub);
      }
      
      if( subint_extract_start >= 0 && subint_extract_end >= 0 ) {
	vector<unsigned> subints;
	unsigned isub = subint_extract_start;

	while ( isub<arch->get_nsubint() && isub<unsigned(subint_extract_end) ) {
	  subints.push_back( isub );
	  isub++;
	}

	Reference::To<Pulsar::Archive> extracted( arch->extract(subints) );
	extracted->set_filename( arch->get_filename() );

	arch = extracted;
      }

      if (tscr) {
	if (tsub > 0.0) {
	  unsigned factor = 
	    unsigned (tsub / arch->get_Integration(0)->get_duration());
	  if (factor == 0) {
	    cerr << "Warning: subints already too long" << endl;
	  }
	  else {
	    arch->tscrunch(factor);
	  }
	  if (verbose)
	    cout << arch->get_filename() << " tscrunched by a factor of " 
		 << factor << endl;
	}
	else if (new_nsub > 0) {
	  arch->tscrunch_to_nsub(new_nsub);
	  if (verbose)
	    cout << arch->get_filename() << " tscrunched to " 
		 << new_nsub << " subints" << endl;
	}
	else if (tscr_fac > 0) {
	  arch->tscrunch(tscr_fac);
	  if (verbose)
	    cout << arch->get_filename() << " tscrunched by a factor of " 
		 << tscr_fac << endl;
	}
	else {
	  arch->tscrunch();
	  if (verbose)
	    cout << arch->get_filename() << " tscrunched" << endl;
	}
      }
      
      if (pscr) {
	arch->pscrunch();
	if (verbose)
	  cout << arch->get_filename() << " pscrunched" << endl;
      } 

      if (invint) {
	arch->invint();
	if (verbose)
	  cout << arch->get_filename() << " invinted" << endl;
      }

      if (newrm) {
	arch->set_rotation_measure (rm);
	if (verbose)
	  cout << arch->get_filename() << " RM set to " << rm << endl;
      }

      if (defaraday) {
	arch->defaraday();
	if (verbose)
	  cout << arch->get_filename() << " defaradayed" <<endl;
      }

      if (aux_rm)
      {
	if (verbose)
	  cout << "pam: correct auxiliary Faraday rotation; iono RM="
	       << aux_rm << endl;
	correct_auxiliary_rm (arch, aux_rm);
      }

      if (fscr) {
	if (new_nchn > 0) {
	  arch->fscrunch_to_nchan(new_nchn);
	  if (verbose)
	    cout << arch->get_filename() << " fscrunched to " 
		 << new_nchn << " channels" << endl;
	}
	else if (fscr_fac > 0) {
	  arch->fscrunch(fscr_fac);
	  if (verbose)
	    cout << arch->get_filename() << " fscrunched by a factor of " 
		 << fscr_fac << endl;
	}
	else {
	  arch->fscrunch();
	  if (verbose)
	    cout << arch->get_filename() << " fscrunched" << endl;
	}
      }

      if (bscr) {
	if (new_nbin > 0) {
	  arch->bscrunch_to_nbin(new_nbin);
	  if (verbose)
	    cout << arch->get_filename() << " bscrunched to " 
		 << new_nbin << " bins" << endl;
	}
	else {
	  arch->bscrunch(bscr_fac);
	  if (verbose)
	    cout << arch->get_filename() << " bscrunched by a factor of " 
		 << bscr_fac << endl;
	}
      }     

      if (smear_dc) {
	for (unsigned i = 0; i < arch->get_nsubint(); i++) {
	  for (unsigned j = 0; j < arch->get_npol(); j++) {
	    for (unsigned k = 0; k < arch->get_nchan(); k++) {
	      smear (arch->get_Profile(i,j,k), smear_dc);
	    }
	  }
	}
      }
      
      if (save) {

	if (archive_class)  {

	  // unload an archive of the specified class
	  Reference::To<Pulsar::Archive> output;
	  output = Pulsar::Archive::new_Archive (archive_class);
	  output -> copy (*arch);
	  output -> set_filename ( arch->get_filename() );

	  arch = output;

	}


	// See if the archive contains a history that should be updated:
	
	Pulsar::ProcHistory* fitsext = arch->get<Pulsar::ProcHistory>();
	
	if (fitsext) {
	  
	  if (command.length() > 80) {
	    cout << "WARNING: ProcHistory command string truncated to 80 chars" 
		 << endl;
	    fitsext->set_command_str(command.substr(0, 80));
	  }
	  else {
	    fitsext->set_command_str(command);
	  }
	  
	}
	
	string out_filename = arch->get_filename();
	
	if( !ext.empty() )
	  out_filename = replace_extension( out_filename, ext );
	
	if( !ulpath.empty() )
	  out_filename = ulpath + basename(out_filename);
	
	arch->unload( out_filename );
	cout << out_filename << " written to disk" << endl;
      }
    }  
    catch (Error& error) {
      cerr << error << endl;
    } 
  
    return 0;

}
catch(Error& er) 
{
  cerr << er << endl;
  return -1;
}
catch (string& error)
{
  cerr << "exception thrown: " << error << endl;
  return -1;
}
catch (bad_alloc& ba)
{
  cerr << "Caught a bad_alloc: '" << ba.what() << "'" << endl ;
  return -1;
}
catch (exception& e)
{
  cerr << "caught an exception of type '" 
				 << typeid(e).name() << "'" << endl; 
  return -1;
}
catch(...)
{
  fprintf(stderr,"Unknown exception caught\n");
  return -1;
}
コード例 #5
0
ファイル: paas.C プロジェクト: lbaehren/lofarsoft
int main (int argc, char** argv) try
{
  // the multiple component model
  ComponentModel model;

  string model_filename_in;
  string model_filename_out = "paas.m";
  string details_filename   = "paas.txt";
  string std_filename       = "paas.std";

  bool fit = false;
  vector<string> new_components;
  string fit_flags;

  int bscrunch = 1;

  string pgdev;

  bool line_plot=false;
  bool interactive = false;
  bool centre_model = false, rotate_peak=false;
  float rotate_amount = 0.0;
  bool align = false;

  const char* args = "hb:r:w:c:fF:it:d:Dl:j:Ws:CpR:a";
  int c;

  while ((c = getopt(argc, argv, args)) != -1)
    switch (c) {

    case 'h':
      usage ();
      return 0;

    case 'r':
      model_filename_in = optarg;
      break;
      
    case 'w':
      model_filename_out = optarg;
      break;
      
    case 'f':
      fit = true;
      break;

    case 'W':
      model.set_fit_derivative (true);
      break;

    case 'c':
      new_components.push_back(optarg);
      break;

    case 'F':
      fit_flags = optarg;
      break;

    case 'b':
      bscrunch = atoi (optarg);
      break;

    case 't':
      model.set_threshold( atof(optarg) );
      break;

    case 'd':
      pgdev = optarg;
      break;

    case 'i':
      interactive = true;
    case 'D':
      pgdev = "/xs";
      break;
      
    case 'l':
      line_plot = true;
      break;

    case 's':
      std_filename = optarg;
      break;

    case 'C':
      centre_model = true;
      break;

    case 'p':
      rotate_peak = true;
      break;

    case 'R':
      rotate_amount = atof(optarg);
      break;

    case 'a':
      align = true;
      break;

    case 'j':
      details_filename = optarg;
      break;

   default:
      cerr << "invalid param '" << c << "'" << endl;
    }

  if (!pgdev.empty())
  {
    cpgopen(pgdev.c_str());
    cpgask(0);
    cpgsvp(0.1, 0.9, 0.1, 0.9);
  }
  
  Reference::To<Archive> archive = Archive::load (argv[optind]);

  // preprocess
  archive->fscrunch();
  archive->tscrunch();
  archive->pscrunch();

  // phase up as requested
  if (centre_model)
    archive->centre();
  else if (rotate_peak)
    archive->centre_max_bin(0.0);
  
  if (rotate_amount != 0.0)
    archive->rotate_phase(-rotate_amount);
  
  archive->remove_baseline();

  // load from file if specified
  if (!model_filename_in.empty())
  {
    cerr << "paas: loading model from " << model_filename_in << endl;
    model.load(model_filename_in.c_str());
    
    // align to profile first if asked
    if (align)
      model.align(archive->get_Integration(0)->get_Profile(0,0));
  }

  // add any new components specified
  unsigned ic, nc=new_components.size();
  double centre, concentration, height;
  int name_start;
  for (ic=0; ic < nc; ic++)
  {
    if (sscanf(new_components[ic].c_str(), 
	       "%lf %lf %lf %n", &centre, &concentration, &height,
	       &name_start)!=3)
    {
      cerr << "Could not parse component " << ic << endl;
      return -1;
    }

    model.add_component(centre, concentration, height, 
			new_components[ic].c_str()+name_start);
  }

  bool iterate = true;

  while (iterate)
  {
    iterate = false;

    // fit if specified
    if (fit)
    {
      // set fit flags
      model.set_infit(fit_flags.c_str());
      // fit
      model.fit(archive->get_Integration(0)->get_Profile(0,0));
    }
 
    // plot
    if (!pgdev.empty())
    {
      Reference::To<Pulsar::Archive> scrunched;
      scrunched = archive->clone();
      if (bscrunch > 1)
	scrunched->bscrunch(bscrunch);

      cpgpage();

      Profile *prof = scrunched->get_Integration(0)->get_Profile(0,0);
      float ymin = prof->min();
      float ymax = prof->max();
      float extra = 0.05*(ymax-ymin);

      ymin -= extra;
      ymax += extra;
      cpgswin(0.0, 1.0, ymin, ymax);
      cpgbox("bcnst", 0, 0, "bcnst", 0, 0);
      cpglab("Pulse phase", "Intensity", "");
      unsigned i, npts=prof->get_nbin();
      cpgsci(14);
      for (ic=0; ic < model.get_ncomponents(); ic++)
	plot(model, npts, true, ic);
      vector<float> xvals(npts);
      cpgsci(4);
      for (i=0; i < npts; i++)
	xvals[i] = i/((double)npts);
      if (line_plot)
	cpgline(npts, &xvals[0], prof->get_amps());
      else
	cpgbin(npts, &xvals[0], prof->get_amps(), 0);
      cpgsci(2);
      plot_difference(model, prof, line_plot);
      cpgsci(1);
      plot(model, npts, true);
    }
    
    
    while (interactive)
    {
      iterate = true;
      fit = false;

      cerr << "Enter command ('h' for help)" << endl;

      float curs_x=0, curs_y=0;
      char key = ' ';
      if (cpgband(6,0,0,0,&curs_x, &curs_y, &key) != 1 || key == 'q')
      {
	cerr << "Quitting ..." << endl;
	iterate = false;
	break;
      }

      if (key == 'h')
      {
	cerr << 
	  "\n"
	  "left click - add a component at cursor position\n"
	  "f key      - fit current set of components\n"
	  "q key      - quit\n"
	  "\n"
	  "After left click:\n"
	  "   1) any key    - select width of new component, then \n"
	  "   2) any key    - select height of new component \n"
	  "\n"
	  "   right click or <Escape> to abort addition of new component \n"
	     << endl;
	continue;
      }
      
      if (key == 'f')
      {
	cerr << "Fitting components" << endl;
	fit = true;
	break;
      }
      
      if (key == 'a' || key == 65)
      {
	cerr << "Adding component centred at pulse phase " << curs_x << endl;
	double centre = curs_x;

	cerr << "Select width and hit any key" << endl;
	if (cpgband(4, 1, curs_x, curs_y, &curs_x, &curs_y, &key) != 1) {
	  cerr << "paas: cpgband error" << endl;
	  return -1;
	}
	
	// right click or escape to abort
	if (key == 88 || key == 27)
	  continue;
	
	double width = fabs(centre - curs_x);
	
	cerr << "Select height and hit any key" << endl;
	if (cpgband(5,0,0,0,&curs_x, &curs_y, &key) != 1) {
	  cerr << "paas: cpgband error" << endl;
	  return -1;
	}
	
	// right click or escape to abort
	if (key == 88 || key == 27)
	  continue;
	
	double height = curs_y;
	
	model.add_component (centre, 0.25/(width*width), height, "");
	
	break;
	
      }
      
      cerr << "Unrecognized command" << endl;
      
    }
    
  }
  
  // write out if specified
  if (!model_filename_out.empty())
  {
    cerr << "paas: writing model to " << model_filename_out << endl;
    model.unload (model_filename_out.c_str());
  }
  
  Reference::To<Pulsar::Archive> copy = archive->clone();

  // write out standard
  model.evaluate (archive->get_Integration(0)->get_Profile(0,0)->get_amps(),
		  archive->get_nbin());

  write_details_to_file (model, copy, archive, details_filename);
  
  cerr << "paas: writing standard to " << std_filename << endl;
  archive->unload (std_filename);

  if (!pgdev.empty())
    cpgend();

  return 0;
}
catch (Error& error)
{
  cerr << error << endl;
  return -1;
}
コード例 #6
0
ファイル: pazi.C プロジェクト: kernsuite-debian/psrchive
int main(int argc, char* argv[]) try
{
  if (argc < 2) {
    usage();
    return EXIT_SUCCESS;
  }
  
  int gotc = 0;
  while ((gotc = getopt(argc, argv, "hvV")) != -1) {
    switch (gotc) {
    case 'h':
      usage();
      return EXIT_SUCCESS;
    case 'V':
      Pulsar::Archive::set_verbosity(3);
      break;
    case 'v':
      Pulsar::Archive::set_verbosity(2);
      break;
    }
  }
  
  if (optind >= argc)
    {
      cerr << "pazi: please specify filename" << endl;
      return -1;
    }
  
  string filename = argv[optind];
  string extension = filename.substr(filename.length() - 2, 2);
  
  if (extension == "rf")
    extension = "rz";
  else if (extension == "cf")
    extension = "cz";
  else
    extension = "pazi";
  
  string write_filename = filename + ".";
  write_filename += extension;
  
  cerr << "pazi: loading data" << endl;
  base_archive = Archive::load(filename);
  
  if (base_archive->get_npol() == 4)
  {
    original_state = base_archive->get_state();
    base_archive->convert_state( Signal::Stokes );
  }
  
  backup_archive = base_archive->clone();
  
  cerr << "pazi: making fscrunched clone" << endl;
  mod_archive = base_archive->clone();
  mod_archive->pscrunch();
  mod_archive->remove_baseline();
  mod_archive->dedisperse();
  mod_archive->fscrunch();

  scrunched_archive = mod_archive->clone();
  scrunched_archive->tscrunch();

  ranges.second = get_max_value(base_archive, plot_type);
  positive_direction = base_archive->get_bandwidth() < 0.0;

  time_orig_plot = factory.construct("time");
  time_mod_plot = factory.construct("time");
  time_fui = time_mod_plot->get_frame_interface();

  freq_orig_plot = factory.construct("freq");
  freq_mod_plot = factory.construct("freq");
  freq_fui = freq_mod_plot->get_frame_interface();

  total_plot = factory.construct("flux");
  total_plot->configure("info=1");

  subint_orig_plot = new ProfilePlot;
  subint_mod_plot = new ProfilePlot;
  subint_fui = subint_mod_plot->get_frame_interface();

  subint_orig_plot->configure("info=1");
  subint_mod_plot->configure("info=1");

  unsigned window = 0;
  char device [8];

  for (unsigned i=0; i<2; i++) do {
    window ++;
    snprintf (device, 8, "%u/XS", window);
  }
  while ( cpgopen (device) < 0 );

  cpgask(0);

  cerr << endl << "Total S/N = " <<
    scrunched_archive->get_Profile(0,0,0)->snr() << endl << endl;

  total_plot->plot(scrunched_archive);
  cpgslct(1);
  time_orig_plot->plot(mod_archive);

  do
  {
    cpgswin(0, 1, 0, 1);

    // plot:
    //   frequency = horizontal mouse band
    //   time      = horizontal mouse band
    //   profile   = vertical mouse band

    int band = 0;

    if (prune_start != UNDEF_MOUSE)
    {
      band = BOX_ANCHOR;
      mouse_ref = prune_start;
    }
    else if (mouse_ref != UNDEF_MOUSE)
    {
      if (plot_type == FscrunchedSubint)
	band = VERTICAL_ANCHOR;
      else
	band = HORIZONTAL_ANCHOR;
    }
    else
    {
      if (plot_type == FscrunchedSubint)
	band = VERTICAL_LINE;
      else
	band = HORIZONTAL_LINE;
    }


    cpgband(band, 0, mouse_ref.first, mouse_ref.second, &(mouse.first),
	    &(mouse.second), &ch);

    switch (ch)
    {

    case 'A': // zoom
      {
	constrain_range(mouse.first);
	constrain_range(mouse.second);

	if (mouse_ref == UNDEF_MOUSE)
        {
	  mouse_ref = mouse;
	  continue;
	}


	// store the current range so it can be restored if the user selects
	// a zoom region too small
	const RangeType old_ranges = ranges;
	bool horizontal = plot_type == FscrunchedSubint ? false : true;
	ranges = get_range(mouse_ref, mouse, ranges, horizontal);

	// ignore mouse clicks if the index values are too close (< 1)
	if (ranges.first == ranges.second) {
	  ranges = old_ranges;
	  break;
	}

	zoomed = true;

	const unsigned max_value = get_max_value(base_archive, plot_type);
	const string zoom_option = get_zoom_option(ranges, max_value);

	switch (plot_type) {
	case PhaseVsTime:
	  time_fui->set_value("y:range", zoom_option);
	  redraw(mod_archive, time_orig_plot, time_mod_plot, zoomed);
	  break;
	case PhaseVsFrequency:
	  freq_fui->set_value("y:range", zoom_option);
	  freq_redraw(mod_archive, base_archive, freq_orig_plot,
		      freq_mod_plot, zoomed);
	  break;
	case FscrunchedSubint:
	  subint_fui->set_value("x:range", zoom_option);
	  redraw(mod_archive, subint_orig_plot, subint_mod_plot, zoomed);
	  break;
	}
      }
      break; // case 'A'
    case 'h':
      usage();
      break;

    case 'b': // plot specific subint
      if (plot_type == PhaseVsTime) {
	plot_type = FscrunchedSubint;
	zoomed = false;

	*mod_archive = *base_archive;
	mod_archive->set_dispersion_measure(0);
	mod_archive->fscrunch();
	mod_archive->pscrunch();
	mod_archive->remove_baseline();

	subint = get_indexed_value(mouse);

	ranges.first = 0;
	ranges.second = get_max_value(base_archive, plot_type);

	char add[3];
	sprintf(add, "%d", subint);
	string subint_option = "subint=";
	subint_option += add;

	subint_orig_plot->configure(subint_option);
	subint_mod_plot->configure(subint_option);

	cpgeras();
	subint_orig_plot->plot(mod_archive);
	update_total(scrunched_archive, base_archive, total_plot);
      }
      break;

      /*case 'c': // center pulse
	set_centre(mod_archive, base_archive, centered, plot_type, dedispersed);

	if (plot_type == "freq")
	redraw(mod_archive, freq_orig_plot, freq_mod_plot, zoomed);
	else if (plot_type == "time")
	redraw(mod_archive, time_orig_plot, time_mod_plot, zoomed);

	update_total(scrunched_archive, base_archive, total_plot);
	break;*/

    case 'd': // toggle dedispersion on/off
      set_dedispersion(mod_archive, base_archive, dedispersed);

      if (plot_type == PhaseVsFrequency) {
	mod_archive->tscrunch();
	redraw(mod_archive, freq_orig_plot, freq_mod_plot, zoomed);
      } else if (plot_type == PhaseVsTime) {
	mod_archive->fscrunch();
	redraw(mod_archive, time_orig_plot, time_mod_plot, zoomed);
      }

      update_total(scrunched_archive, base_archive, total_plot);
      break;

    case 'f': // frequency plot
      plot_type = PhaseVsFrequency;
      ranges.first = 0;
      ranges.second = get_max_value(base_archive, plot_type);
      zoomed = false;
      freq_redraw(mod_archive, base_archive, freq_orig_plot, freq_mod_plot, zoomed);
      break;

    case 'm':

      if (plot_type != FscrunchedSubint)
      {
	cerr << "pazi: can only mow lawn in binzap-subint mode" << endl;
	continue;
      }

      cerr << "pazi: mowing lawn" << endl;
      mowlawn (mod_archive, base_archive, subint);

      cerr << "pazi: replotting" << endl;
      redraw(mod_archive, subint_orig_plot, subint_mod_plot, zoomed);
      cerr << "pazi: updating total" << endl;
      update_total(scrunched_archive, base_archive, total_plot);

      break;

    case 'x': // prune

      if (plot_type != FscrunchedSubint)
      {
	cerr << "pazi: can only prune hedge in binzap-subint mode" << endl;
	continue;
      }

      constrain_range(mouse.first);
      constrain_range(mouse.second);

      if (prune_start == UNDEF_MOUSE)
      {
	prune_start = mouse;
	continue;
      }

      prune_end = mouse;

      cerr << "pazi: pruning hedge" << endl;
      prune_hedge (mod_archive, base_archive, subint);

      cerr << "pazi: replotting" << endl;
      redraw(mod_archive, subint_orig_plot, subint_mod_plot, zoomed);
      cerr << "pazi: updating total" << endl;
      update_total(scrunched_archive, base_archive, total_plot);

      break;

    case 'o': // toggle frequency scrunching on/off
      if (plot_type == PhaseVsTime)
      {
	if (fscrunched) {
	  fscrunched = false;
	  *mod_archive = *base_archive;
	}
	else {
	  fscrunched = true;
	  mod_archive->fscrunch();
	}
	redraw(mod_archive, time_orig_plot, time_mod_plot, zoomed);
      }
      break;

    case 'q': // quit
      cpgclos();
      return EXIT_SUCCESS;

    case 'p':
      print_command(channels_to_zap, subints_to_zap, extension, filename);
      break;

    case 'r': // reset zoom
      zoomed = false;
      ranges.first = 0;
      ranges.second = get_max_value(base_archive, plot_type);

      switch (plot_type) {
      case PhaseVsTime:
	redraw(mod_archive, time_orig_plot, time_mod_plot, zoomed);
	break;
      case PhaseVsFrequency:
	freq_redraw(mod_archive, base_archive, freq_orig_plot,
		    freq_mod_plot, zoomed);
	break;
      case FscrunchedSubint:
	redraw(mod_archive, subint_orig_plot, subint_mod_plot, zoomed);
	break;
      }
      break;

    case 's': // save current archive changes:
      {
	Pulsar::ProcHistory* ext = base_archive->get<Pulsar::ProcHistory>();
	if (ext) {
	  ext->set_command_str("pazi");
	}

	if ( base_archive->get_npol() == 4 )
	  base_archive->convert_state( original_state );
	base_archive->unload(write_filename);
	if ( base_archive->get_npol() == 4 )
	  base_archive->convert_state( Signal::Stokes );
	break;
      }

    case 't': // time plot
      plot_type = PhaseVsTime;
      ranges.first = 0;
      ranges.second = get_max_value(base_archive, plot_type);
      zoomed = false;
      time_redraw(mod_archive, base_archive, time_orig_plot, time_mod_plot, zoomed);
      break;

    case 'u': // undo last change

      if (mouse_ref != UNDEF_MOUSE) {
	mouse_ref = UNDEF_MOUSE;
	continue;
      }

      switch (plot_type) {
      case PhaseVsTime:
	{
	  const unsigned value = get_indexed_value(mouse);
	  remove_channel(value, subints_to_zap);
	  time_unzap_subint(base_archive, backup_archive, value);
	  time_redraw(mod_archive, base_archive, time_orig_plot,
		      time_mod_plot, zoomed);
	}
	break;
      case PhaseVsFrequency:
	{
	  const unsigned value = get_indexed_value(mouse);
	  remove_channel(value, channels_to_zap);
	  freq_unzap_chan(base_archive, backup_archive, value);
	  freq_redraw(mod_archive, base_archive, freq_orig_plot,
		      freq_mod_plot, zoomed);
	}
	break;
      case FscrunchedSubint:
	if (bins_to_zap.size()) {
	  bins_to_zap.erase(bins_to_zap.end() - 5, bins_to_zap.end());

	  *base_archive = *backup_archive;
	  *mod_archive = *backup_archive;

	  mod_archive->set_dispersion_measure(0);
	  mod_archive->pscrunch();
	  mod_archive->fscrunch();
	  mod_archive->remove_baseline();
	  redraw(mod_archive, subint_orig_plot, subint_mod_plot, zoomed);
	}
	break;
      }
      update_total(scrunched_archive, base_archive, total_plot);
      break;

    case 'z':
    case 'X': // zap single channel

      if (mouse_ref == UNDEF_MOUSE)
	zap_single ();
      else
	zap_multiple ();

      break;
    }

    prune_start = UNDEF_MOUSE;
    mouse_ref = UNDEF_MOUSE;

  } while (ch != 'q');

  return 0;

 } // end main

 catch (Error& error) {
   cerr << "pazi: " << error << endl;
   return -1;
 }
コード例 #7
0
ファイル: paz.C プロジェクト: SkyTian13/psrchive
void paz::process (Pulsar::Archive* arch)
{
  if (periodic_zap)
  {
    if (arch->get_nchan () == 1)
      cout << periodic_zap_warning << endl;

    for (unsigned pol = 0; pol < arch->get_npol (); pol++)
      for (unsigned chan = 0; chan < arch->get_nchan (); chan++)
	for (unsigned subint = 0; subint < arch->get_nsubint (); subint++)
	  zap_periodic_spikes (arch->get_Profile (subint, pol, chan),
			       periodic_zap_period, periodic_zap_phase,
                               periodic_zap_width);
  }

  if (pol_to_delete != -1)
  {
    /*
      Delete either PP=(pol 0) or QQ=(pol 1) by resizing to npol = 1

      If PP is to be deleted, PP and QQ are first swapped.
    */

    if (pol_to_delete != 0 && pol_to_delete != 1)
      throw Error (InvalidState, "paz::process",
		   "--pol = either 0 or 1, not %d", pol_to_delete);

    if (arch->get_state() == Signal::Stokes)
      arch->convert_state( Signal::Coherence );

    Signal::State state = arch->get_state();

    if (state != Signal::Coherence && state != Signal::PPQQ)
      throw Error (InvalidState, "paz::process",
		   "cannot delete polarization when state = %s", 
		   Signal::state_string(state));

    if (verbose)
      cerr << "paz: deleting ipol=" << pol_to_delete 
	   << " current state=" << Signal::state_string(state) << endl;

    const unsigned nchan = arch->get_nchan ();
    const unsigned nsub = arch->get_nsubint ();

    for (unsigned isub = 0; isub < nsub; isub++)
    {
      // ensure that the sub-integration is loaded from file
      Pulsar::Integration* subint = arch->get_Integration (isub);

      if (pol_to_delete == 0)
      {
        // Swap pol 0 and pol 1 in each sub-integration and frequency channel
	for (unsigned ichan = 0; ichan < nchan; ichan++)
	  subint->expert()->swap_profiles (0, ichan, 1, ichan);
      }
    }

    // resize to npol = 1
    arch->resize (nsub, 1);
    arch->set_state( Signal::Intensity );
  } 

  // To fix early wide-band correlator problem
  if (eightBinZap)
  {
    for (unsigned pol = 0; pol < arch->get_npol (); pol++) {
      for (unsigned chan = 0; chan < arch->get_nchan (); chan++) {
	for (unsigned subint = 0; subint < arch->get_nsubint (); subint++) {
	  Pulsar::Profile * prof = arch->get_Profile (subint, pol, chan);
	  float *amps = prof->get_amps ();
	  for (unsigned i = 5; i < arch->get_nbin (); i += 8) {
	    // Interpolate between previous and later point if possible
	    if (i == arch->get_nbin () - 1)
	      amps[i] = amps[i - 1];
	    else {
	      float amp1 = amps[i - 1];
	      float amp2 = amps[i + 1];
	      amps[i] = 0.5 * (amp1 + amp2);
	    }
	  }
	  prof->set_amps (amps);
	}
      }
    }
  }

  unsigned nchan = arch->get_nchan ();
  double chan_bw = fabs(arch->get_bandwidth() / (double)nchan);

  if (subs_to_delete.size())
  {
    unsigned zapped = 0;
    unsigned orig_nsubint = arch->get_nsubint ();

    for (unsigned i = 0; i < orig_nsubint; i++)
      for (unsigned j = 0; j < subs_to_delete.size (); j++)
	if (subs_to_delete[j] == i)
	{
	  if (verbose)
	    cout << "Deleting subint " << i << endl;

	  // after each subint is zapped, it is necessary to offset the index
	  arch->erase (i - zapped);
	  zapped ++;
	}

    if (verbose)
      cerr << "paz: deletion completed" << endl;
  }

  if (subs_no_delete.size())
  {
    unsigned zapped = 0;
    unsigned orig_nsubint = arch->get_nsubint ();

    for (unsigned i = 0; i < orig_nsubint; i++)
    {
      bool keep = false;
      for (unsigned j = 0; j < subs_no_delete.size (); j++)
	if (subs_no_delete[j] == i)
	  keep = true;

      if (!keep)
      {
	if (verbose)
	  cout << "Deleting subint " << i << endl;

	// after each subint is zapped, it is necessary to offset the index
	arch->erase (i - zapped);
	zapped ++;
      }
    }

    if (verbose)
      cerr << "paz: deletion completed" << endl;
  }

  if (median_zapper)
  {
    cout << "Using median smoothed difference zapper" << endl;
    (*median_zapper) (arch);
  }

  if (modulation_zapper)
  {
    cout << "Using modulation index zapper" << endl;
    (*modulation_zapper) (arch);
  }

  if (simple)
  {
    cout << "Using simple mean offset zapper" << endl;
    zapper->zap_chans (arch);
    cout << "Zapping complete" << endl;
  }

  if (subs_to_zero.size() && !zero_intersection)
  {
    vector<float> mask (nchan, 0.0);
    zapper->zap_very_specific (arch, mask, subs_to_zero);
  }

  if (bins_to_zap.size ())
  {
    for (unsigned i = 0; i < bins_to_zap.size(); ++i)
      zap_bin_in_archive(arch, bins_to_zap[i]);
  }

  if (zero_channels)
  {
    vector<float> mask (nchan, 1.0);
    for (unsigned i = 0; i < chans_to_zero.size (); i++)
    {
      if (chans_to_zero[i] >= nchan || chans_to_zero[i] < 0)
        throw Error (InvalidRange, "paz::process",
            "channel %d is out of range (nchan=%d)",
           chans_to_zero[i], nchan); 
      mask[chans_to_zero[i]] = 0.0;
    }

    for (unsigned i = 0; i < freqs_to_zero.size (); i++)
    {
      for (unsigned ic=0; ic<nchan; ic++)
      {
	double chan_freq=arch->get_Integration(0)->get_centre_frequency(ic);
	if ( freqs_to_zero[i] > chan_freq - chan_bw/2.0 
	     && freqs_to_zero[i] < chan_freq + chan_bw/2.0 )
	  mask[ic] = 0.0;
      }
    }

    for (unsigned i=0; i< freq_ranges_to_zero.size(); i++)
    {
      for (unsigned ic=0; ic<nchan; ic++)
      {
	FreqRange chan;
	chan.lo=arch->get_Integration(0)->get_centre_frequency(ic) 
	  - chan_bw/2.0;
	chan.hi=arch->get_Integration(0)->get_centre_frequency(ic) 
	  + chan_bw/2.0;
	if (chan.lo > freq_ranges_to_zero[i].lo 
	    && chan.lo < freq_ranges_to_zero[i].hi)
	  mask[ic] = 0.0;
	else if (chan.hi > freq_ranges_to_zero[i].lo 
		 && chan.hi < freq_ranges_to_zero[i].hi)
	  mask[ic] = 0.0;
	else if (freq_ranges_to_zero[i].lo > chan.lo 
		 && freq_ranges_to_zero[i].lo < chan.hi)
	  mask[ic] = 0.0;
      }
    }
    
    if (zero_intersection)
      zapper->zap_very_specific (arch, mask, subs_to_zero);
    else
      zapper->zap_specific (arch, mask);
  }
  
  if (edge_zap_percent)
  {
    float fraction = edge_zap_percent / 100.0;
    unsigned buffer = unsigned (float (nchan) * fraction);

    vector < float >mask (nchan, 0.0);

    for (unsigned i = buffer; i < (nchan - buffer); i++)
      mask[i] = 1.0;

    zapper->zap_specific (arch, mask);
  }

  if (ston_cutoff > 0.0)
  {
    double theston = 0.0;
    Reference::To<Pulsar::Archive> cloned = arch->clone();
    cloned->pscrunch ();
    for (unsigned isub = 0; isub < arch->get_nsubint (); isub++) {
      for (unsigned ichan = 0; ichan < arch->get_nchan (); ichan++) {
	theston = cloned->get_Profile (isub, 0, ichan)->snr ();
	if (theston < ston_cutoff) {
	  arch->get_Integration (isub)->set_weight (ichan, 0.0);
	}
      }
    }
  }

  if (dropout_sigma)
  {
    Reference::To < Pulsar::Archive > cloned = arch->clone ();
    Reference::To < Pulsar::Profile > testprof = 0;

    cloned->pscrunch ();
    cloned->fscrunch ();
    cloned->remove_baseline ();

    vector < double >mins;
    for (unsigned isub = 0; isub < arch->get_nsubint (); isub++) {
      testprof = cloned->get_Profile (isub, 0, 0);
      mins.push_back (fabs (testprof->min ()));
    }

    cloned->tscrunch ();

    double mean, vari, varm;

    testprof = cloned->get_Profile (0, 0, 0);
    testprof->stats (&mean, &vari, &varm);

    for (unsigned isub = 0; isub < arch->get_nsubint (); isub++) {
      if (mins[isub] > dropout_sigma * sqrt (vari)) {
	cerr << "Zapping integration " << isub << endl;
	arch->get_Integration (isub)->uniform_weight (0.0);
      }
    }
  }

  if (mower)
  {
    if (mow_all_subints)
    {
      subints_to_mow.resize (arch->get_nsubint ());
      for (unsigned isub = 0; isub < arch->get_nsubint (); isub++)
	subints_to_mow[isub] = isub;
    }

    for (unsigned isub = 0; isub < subints_to_mow.size (); isub++)
    {
      cerr << "paz: mowing subint " << subints_to_mow[isub] << endl;
      mower->transform (arch->get_Integration (subints_to_mow[isub]));
    }
  }
}
コード例 #8
0
ファイル: spa.C プロジェクト: lbaehren/lofarsoft
int main (int argc, char *argv[])
{
  bool  verbose    = false;
  bool  gaussian   = false;
  float factor     = 5.0;
  bool  log        = false;
  bool  shownoise  = false;
  int   method     = 0;
  int   bins       = 30;
  float cphs       = 0.0;
  float dcyc       = 0.0;
  float norm       = 0.0;

  int gotc = 0;

  while ((gotc = getopt(argc, argv, "qvVhlg:p:w:n:b:Gs")) != -1) {
    switch (gotc) {
    case 'h':
      usage ();
      return 0;

    case 'v':
      Pulsar::Archive::set_verbosity(2);
      verbose = true;
      break;

    case 'V':
      verbose = true;
      Pulsar::Archive::set_verbosity(3);
      break;

    case 'l':
      log = true;
      break;

    case 'g':
      factor = atof(optarg);
      break;

    case 'n':
      norm = atof(optarg);
      break;
      
    case 'p':
      cphs = atof(optarg);
      if (cphs > 0.0 && cphs < 1.0) {
	method = 2;
      }
      else {
	method = 1;
      }
      break;
      
    case 'w':
      dcyc = atof(optarg);
      break;

    case 'b':
      bins = atoi(optarg);
      break;

    case 'G':
      gaussian = true;
      break;

    case 's':
      shownoise = true;
      break;
      
    default:
      cout << "Unrecognised option: " << gotc << endl;
    }
  }
 
  vector<string> archives;
  vector<pulse>  pulses;
  vector<pulse>  noise;
  vector<pulse>  pgiants;
  vector<pulse>  ngiants;
  vector<hbin>   pdata;
  vector<hbin>   ndata;

  Reference::To<Pulsar::Archive> arch;

  for (int ai = optind; ai < argc; ai++)             // extract filenames
    dirglob (&archives, argv[ai]);
  
  try {
    
    cout << "Loading archives and extracting data..." << endl;
    
    for (unsigned i = 0; i < archives.size(); i++) {
      
      if (verbose) cerr << "Loading " << archives[i] << endl;

      arch = Pulsar::Archive::load(archives[i]);
      
      arch->fscrunch();        // remove frequency and polarisation resolution
      arch->pscrunch();
      arch->remove_baseline(); // Remove the baseline level

      scan_pulses(arch, pulses, method, cphs, dcyc);
      if (shownoise)
	scan_pulses(arch, noise, 2, arch->find_min_phase(dcyc), dcyc);
    }
    
    float offset = 2.0;
    
    if (shownoise) {
      offset = noise[0].flx;
      for (unsigned i = 1; i < noise.size(); i++)
	if (noise[i].flx < offset) offset = noise[i].flx;
      offset = fabs(offset);
      offset /= norm;
    }
    
    float threshold = find_giants(pulses, pgiants, factor, norm, offset);
    cout << "Detection threshold is roughly " << threshold << endl;

    display_giants(pgiants);

    prob_hist(pulses, pdata, bins);

    float submin = pdata[0].x;
    float submax = pdata[0].x;
    
    for (unsigned i = 1; i < pdata.size(); i++) {
      if (pdata[i].x > submax) submax = pdata[i].x;
      if (pdata[i].x < submin) submin = pdata[i].x;
    }

    if (shownoise) {
      find_giants(noise, ngiants, factor, norm, offset);
      prob_hist(noise, ndata, bins, submin, submax);
    }
    
    unsigned useful = 0;
    if (log) {
      vector<hbin>::iterator it = pdata.begin();
      while (it != pdata.end()) {
	if (pdata[useful].x < 0) {
	  pdata.erase(it);
	  continue;
	}
	else {
	  pdata[useful].x = logf(pdata[useful].x);
	  it++;
	  useful++;
	}
      }
      threshold = logf(threshold);
    }
    
    float xmin, xmax, ymin, ymax;
    
    xmin = xmax = pdata[0].x;
    ymin = ymax = pdata[0].y;
    
    // Find the extremes of the data set
    
    for (unsigned i = 1; i < pdata.size(); i++) {
      if (pdata[i].x > xmax) xmax = pdata[i].x;
      if (pdata[i].x < xmin) xmin = pdata[i].x;
      if (pdata[i].y > ymax) ymax = pdata[i].y;
      if (pdata[i].y < ymin) ymin = pdata[i].y;
    }

    
    // Plot pulse intensity probability distribution
    
    cpgopen("?");
    cpgsvp(0.1,0.9,0.15,0.9);
    cpgsci(7);
    cpgsch(1.3);
    
    cpgswin(xmin-(xmin/100.0), xmax+(xmax/100.0),
	    logf(ymin-(ymin/2.0)), logf(ymax+(ymax/2.0)));
    
    cpgbox("BCNST", 0.0, 0, "BCNST", 0.0, 0);
    cpgsci(8);
    if (log)
      cpglab("Log (Normalised Pulse Flux)", "Log (P(I))", "");
    else 
      cpglab("Normalised Pulse Flux", "Log (P(I))", "");
    cpgsci(5);
    
    // Plot the pulse detection threshold
    cpgsls(3);
    cpgsci(3);
    cpgmove(threshold, logf(ymin-(ymin/2.0)));
    cpgdraw(threshold, logf(ymax+(ymax/2.0)));
    cpgsls(1);

    // Plot points and associated error bars
    for (unsigned i = 0; i < pdata.size(); i++) {
      cpgpt1(pdata[i].x, logf(pdata[i].y), 4);
      cpgerr1(6, pdata[i].x, logf(pdata[i].y), pdata[i].e/pdata[i].y, 1.0);
    }

    if (gaussian) {
          
      MEAL::Gaussian gm1;
      
      fit_gauss(pdata, gm1);
      
      gm1.set_abscissa(xmin);
      cpgmove(xmin,logf(gm1.evaluate()));

      cpgsci(2);
      cpgsls(2); 
      
      float xval = 0.0;

      for (unsigned i = 1; i < 1000; i++) {
	xval = xmin+((xmax-xmin)/1000.0*i);
	gm1.set_abscissa(xval);
	cpgdraw(xval,logf(gm1.evaluate()));
      }

      if (shownoise) {
	
	MEAL::Gaussian ngm;

	fit_gauss(ndata, ngm);
	
	ngm.set_abscissa(xmin);
	cpgmove(xmin,logf(ngm.evaluate()));
	
	cpgsci(5);
	cpgsls(4); 

	for (unsigned i = 1; i < 1000; i++) {
	  xval = xmin + ((xmax-xmin)/250.0*i);
	  ngm.set_abscissa(xval);
	  if (log)
	    cpgdraw(logf(xval),logf(ngm.evaluate()));
	  else
	    cpgdraw(xval,logf(ngm.evaluate()));
	}
      }
    }

    cpgclos();

    // Free any used memory
    archives.clear();
    pulses.clear();
    noise.clear();
    pgiants.clear();
    ngiants.clear();
    pdata.clear();
    ndata.clear();
  }
  catch (Error& error) {
    fflush(stdout); 
    cerr << error << endl;
    exit(1);
  }
  
  fflush(stdout);
  return 0;
}