SPB::BandSolver::BandSolver(const Lattice &L):dim(L.dim),shapeset(L.dim, L.Lr){
// set defaults
res[0] = 16;
res[1] = 16;
res[2] = ((2 == dim) ? 1 : 16);
IRA_data.work = NULL;
IRA_data.n_arnoldi = 0;
IRA_data.n_alloc = 0;
material.reserve(16);
SetVerbosity(9);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
bool TestInterface::SetVerbosity(int ival)
{
if (!fdmExec) return 0;
// if (!IsAircraftLoaded()) return 0;
// even when aircraft is null we must be able to set verbosity level
if (ival <= eVeryVerbose)
{
SetVerbosity( (JIVerbosityLevel)ival );
}
else
return 0;
return 1;
}
//--------------------------------------------------------------------
void KFSvcManager::Init()
//--------------------------------------------------------------------
{
log4cpp::Category& klog = log4cpp::Category::getRoot();
klog << log4cpp::Priority::DEBUG <<
"In KFSvcManagerSvc::Init() " ;
fModel = Model();
fDim = ModelDim();
fKFRep = KFRep();
klog << log4cpp::Priority::INFO
<< "--: model = " << fModel
<< " dimension = " << fDim
<< " representation = " << fKFRep;
klog << log4cpp::Priority::DEBUG
<< "Select the model, fitter and rep";
// select the model
fRPMan.model_svc().select_model(fModel);
// select the Kalman Filter as fitting algorithm
fRPMan.fitting_svc().select_fitter(RP::kalman);
//select the default representation
//RP::rep().set_default_rep_name(RP::pos_dir_curv);
// default fitting representation (should be selected before trying to retrieve a fitter)
fRPMan.fitting_svc().set_fitting_representation(fKFRep);
klog << log4cpp::Priority::DEBUG
<< "Select the max chi2, max number outliers & extrap failures";
// set the maximum local chi2 allowed
fRPMan.fitting_svc().retrieve_fitter<KalmanFitter>(RP::kalman,fModel).
set_max_local_chi2ndf(KFSetup::Instance().MaxChi2());
// set the maximum number of outliers allowed
fRPMan.fitting_svc().retrieve_fitter<KalmanFitter>(RP::kalman,fModel).
set_number_allowed_outliers(KFSetup::Instance().MaxOutliers());
// set the maximum number of consecutive extrapolation failures when predicting in the Kalman Filter
fRPMan.fitting_svc().retrieve_fitter<KalmanFitter>(RP::kalman,fModel).
set_max_consecutive_extrap_failures(KFSetup::Instance().MaxExtrapFailures());
klog << log4cpp::Priority::DEBUG
<< "Init geometrical limits";
// initialize geometrical limits
fRPMan.geometry_svc().set_zero_length(1e-3 * mm);
fRPMan.geometry_svc().set_infinite_length(1e12 * mm);
// minimum distance between nodes to check the node ordering.
// Specially for P0D which can have clusters at the same layer with different z positions
fRPMan.matching_svc().set_min_distance_node_ordering(KFSetup::Instance().MinDistanceNodeOrdering());
// minimum number of nodes to be check for good ordering
fRPMan.matching_svc().set_min_good_node_ordering(KFSetup::Instance().MinGoodNodeOrdering());
klog << log4cpp::Priority::DEBUG
<< "Enable MS, disable energy loss fluctuations, enable energy loss correction";
// enable multiple scattering by default
fRPMan.model_svc().enable_noiser(fModel, RP::ms, true);
// enable energy loss fluctuations by default
fRPMan.model_svc().enable_noiser(fModel, RP::eloss, false);
// enable electron energy loss fluctuations (bremsstrahlung) by default
fRPMan.model_svc().enable_noiser(fModel, RP::electron_eloss, false);
// enable electron energy loss correction (bremsstrahlung) by default
fRPMan.model_svc().enable_correction(fModel, RP::brem_eloss, false);
// enable energy loss correction by default
fRPMan.model_svc().enable_correction(fModel, RP::eloss, false);
// By default no preselected length sign is used when intersecting a surface
fRPMan.model_svc().model(fModel).intersector().set_length_sign(0);
// The geometry is not initialized for this manager
fRPMan.geometry_svc().set_status("ready",false);
klog << log4cpp::Priority::DEBUG
<< "Initialize Manager Geometry";
InitializeManagerGeometry();
klog << log4cpp::Priority::DEBUG
<< "Set up the surface maker";
// Set up the surface maker
fRPMan.matching_svc().add_surface_maker("global",new KFSurfaceMaker(&(fRPMan.matching_svc()), &(fRPMan.geometry_svc().setup())));
fRPMan.matching_svc().select_surface_maker("global");
klog << log4cpp::Priority::DEBUG
<< "Set Verbosity();";
SetVerbosity();
}
int main(int argc, char *argv[]) {
int arg=1;
int sbig_type = NO_CAMERA;
int info_mode = 0;
int verbose = 0;
char name[MAX_STRING] = "";
char ra[MAX_STRING] = "";
char dec[MAX_STRING] = "";
char alt[MAX_STRING] = "";
char az[MAX_STRING] = "";
char imtype[8];
int phase;
float exptime;
int err;
/* Set an interrupt handler to trap Ctr-C nicely */
if(signal(SIGINT, SIG_IGN) != SIG_IGN)
signal(SIGINT, InterruptHandler);
/* set lockfile from the outset */
get_lock();
store_pid_in_lockfile();
/* parse args */
if (argc < 3) {
error_exit(usage);
};
while (arg < argc - 2)
{
switch (argv[arg++][1]) {
case 'v':
verbose = 1;
SetVerbosity(verbose);
break;
case 'n':
sscanf(argv[arg++], "%s", name);
break;
case 'r':
sscanf(argv[arg++], "%s", ra);
break;
case 'd':
sscanf(argv[arg++], "%s", dec);
break;
case 'a':
sscanf(argv[arg++], "%s", alt);
break;
case 'z':
sscanf(argv[arg++], "%s", az);
break;
default:
error_exit(usage);
break;
}
}
sscanf(argv[arg++],"%s",imtype);
sscanf(argv[arg++],"%f",&exptime);
// Determine what kind of image to take
switch(value_from_imagetype_key(imtype)) {
case DARK: ccd_type=DARK; if (verbose) printf("Taking dark frame.\n"); break;
case LIGHT: ccd_type=LIGHT; if (verbose) printf("Taking light frame.\n"); break;
case BIAS: ccd_type=BIAS; if (verbose) printf("Taking bias frame.\n"); break;
case FLAT: ccd_type=FLAT; if (verbose) printf("Taking flat frame.\n"); break;
case BADKEY: fprintf(stderr,"Unknown image type %s\n",imtype); return(1); break;
}
fflush(stdout);
CountCameras();
if (ccd_ncam < 1){
fprintf(stderr,"Found 0 cameras\n");
return(1);
}
InitializeAllCameras();
store_timestamped_note_in_lockfile("Started");
store_directory_in_lockfile();
char myline[128];
sprintf(myline,"Exptime: %5.1f\n",exptime);
store_note_in_lockfile(myline);
// Start integrations going on each of the cameras one by one.
for (int cam_num = 0; cam_num <ccd_ncam; cam_num++)
{
err = SetActiveCamera(cam_num);
ccd_image_data[cam_num] =
(unsigned short *) malloc(ccd_image_width*ccd_image_height*sizeof(unsigned short));
phase = 0;
err = CaptureImage(&phase,ccd_image_data[cam_num],ccd_type,exptime,FALSE,0,0,0,0);
}
// Wait until the data is ready. I'm intentionally playing this safe by
// making sure I wait at least 1s before trying to read out the data.
// This is something I will have to look into if I ever use this for
// fast focusing.
int nsec = (int) exptime + 1;
int count = 0;
for (int i=0; i<=nsec;i++)
{
if(nsec > 3 && nsec < 10){
load_bar(count++,nsec,3,30);
}
else if (nsec > 10 && nsec < 100){
load_bar(count++,nsec,(int)(nsec/2),30);
}
else if (nsec > 100){
load_bar(count++,nsec,(int)(nsec/3),30);
}
sleep(1);
}
// The cameras are ready to be read out. We once again cycle over each camera and
// save the data.
for (int cam_num = 0; cam_num <ccd_ncam; cam_num++)
{
char infoline[128];
phase = 1;
err = SetActiveCamera(cam_num);
fflush(stderr);
err = CaptureImage(&phase,ccd_image_data[cam_num],ccd_type,exptime,FALSE,0,0,0,0);
// Print out some pixel values to let the user check data integrity
if (verbose)
printf("Some pixel values: %u %u %d\n",
*(ccd_image_data[cam_num] + 10000),
*(ccd_image_data[cam_num] + 15000),
*(ccd_image_data[cam_num]+20000));
// Figure out what to call the new file
char *newname;
newname = (char *)malloc(MAX_STRING*sizeof(char));
new_filename(ccd_serial_number,imtype,newname);
// Save as a FITS file
GetCameraTemperature();
double temperature = ccd_camera_info[ActiveCamera()].temperature;
int filterNumber = 0;
if (IsCameraAnST402ME())
filterNumber = FilterWheelPosition();
write_fits(newname, ccd_image_width, ccd_image_height, ccd_image_data[cam_num],
exptime,imtype,temperature,filterNumber,ccd_serial_number, name,
ra,dec,alt,az);
fprintf(stderr,"Saved %s \n",newname);
sprintf(infoline,"Camera %d wrote: %s\n",cam_num,newname);
store_note_in_lockfile(infoline);
free(ccd_image_data[cam_num]);
free(newname);
}
DisconnectAllCameras();
release_lock();
store_timestamped_note_in_lockfile("Completed");
// Release the lock file
release_lock();
// Ring bell to wake up the astronomer
if (verbose)
printf("Camera(s) opened and closed successfully.\n");
putchar('\a'); putchar('\a'); putchar('\a');
return(0);
}
void FLogCategoryBase::ResetFromDefault()
{
// regularize the default verbosity to be at most whatever we were compiled with
SetVerbosity(ELogVerbosity::Type(DefaultVerbosity));
}
