int main(void)
{
double c;
double g;
double x;
printf("hello world!\n");
c=average(5,2);
printf("c=%f\n",c);
c=absolute(5);
printf("c=%f\n",c);
c=absolute(-5);
printf("c=%f\n",c);
printf("------\n");
x=1.0;
printf("x=%f\n",x);
x=improve(x);
printf("x=%f\n",x);
x=improve(x);
printf("x=%f\n",x);
x=improve(x);
printf("x=%f\n",x);
x=improve(x);
printf("x=%f\n",x);
x=improve(x);
printf("x=%f\n",x);
x=improve(x);
printf("x=%f\n",x);
x=improve(x);
printf("x=%f\n",x);
x=improve(x);
printf("x=%f\n",x);
}
void compute() {
StateId* maxEnds = 0;
if (maxEnd) {
maxEnd->clear();
maxEnd->resize(nStates);
maxEnds = &maxEnd->front();
}
for (StateId from = 0; from < nStates; ++from) { // ultimate source
Weight* distancesFrom = distances.row(from);
distancesFrom[from] = oneWeight;
StateId maxEndFrom = 0;
for (StateId via = from; via < nStates; ++via) {
Weight& viaWt = distancesFrom[via];
if (viaWt == zeroWeight) continue;
// TODO: slight speedup: maintain reachability set (log n or bit vector, instead of n)
if (!keep()(viaWt)) {
if (kZeroDropped) viaWt = zeroWeight;
continue; // we already don't care for from->via. definitely don't continue it.
}
maxEndFrom = via;
// for outarcs of via:
ArcId nArcs = hg.numOutArcs(via);
for (ArcId a = 0; a < nArcs; ++a) {
Arc const& arc = *hg.outArc(via, a);
ArcId to = arc.head();
checkTopoSort(from, to);
assert(to < distances.getNumCols());
improve(distancesFrom[to], viaWt, ArcWtFn::operator()(&arc));
// don't reject head yet (semiring may accumulate sums).
}
}
if (maxEnds) maxEnds[from] = maxEndFrom;
}
}
void search(D &d, typename D::State &s0) {
bool optimal = false;
this->rowhdr();
this->start();
this->closed.init(d);
this->incons.init(d);
Node *n0 = this->init(d, s0);
this->closed.add(n0);
this->open.push(n0);
unsigned long n = 0;
do {
if (improve(d)) {
n++;
double epsprime = this->wt == 1.0 ? 1.0 : this->findbound();
if (this->wt < epsprime)
epsprime = this->wt;
this->row(n, epsprime);
}
if (this->wt <= 1.0)
optimal = true;
if (this->wt <= 1.0 || shouldstop())
break;
this->nextwt();
this->updateopen();
this->closed.clear();
} while(!shouldstop() && !this->limit() && !this->open.empty());
this->finish();
dfpair(stdout, "converged", "%s", optimal ? "yes" : "no");
}
double Sqrt_iter(double guess,double x)
{
if(good_enough(guess,x)) return guess;
else{
printf("cccc\n");
return Sqrt_iter(improve(guess,x),x);
}
}
int main() {
int k, start, ending;
int flag;
int i1;
k = 0;
start = 99;
ending = 100;
flag = 0;
build(start, ending);
while (find(ending, start, flag)>0) {
improve(ending);
}
printf("%d \n", ans); /* ans is 49 */
return 0;
}
//reduce redistributes, updates 07/02/15 rnc
int main(int argc, char **argv) {
//// Initializations ---------------------------------------------
srand48(1234); // Make sure we have reproducability
check_args(argc);
Time t, time; // t for global, time for local
init_time(t);
Feat F;
MTL M;
// Read parameters file //
F.readInputFile(argv[1]);
printFile(argv[1]);
// Read Secretfile
// Secret contains the identity of each target: QSO-Ly-a, QSO-tracers, LRG, ELG, fake QSO, fake LRG, SS, SF
Gals Secret;
printf("before read secretfile \n");
init_time_at(time,"# read Secret file",t);
Secret=read_Secretfile(F.Secretfile,F);
printf("# Read %d galaxies from %s \n",Secret.size(),F.Secretfile.c_str());
print_time(time,"# ... took :");
std::vector<int> count(10);
count=count_galaxies(Secret);
printf(" Number of galaxies by type, QSO-Ly-a, QSO-tracers, LRG, ELG, fake QSO, fake LRG, SS, SF\n");
for(int i=0;i<8;i++){if(count[i]>0)printf (" type %d number %d \n",i, count[i]);}
//read the three input files
init_time_at(time,"# read target, SS, SF files",t);
MTL Targ=read_MTLfile(F.Targfile,F,0,0);
MTL SStars=read_MTLfile(F.SStarsfile,F,1,0);
MTL SkyF=read_MTLfile(F.SkyFfile,F,0,1);
print_time(time,"# ... took :");
//combine the three input files
M=Targ;
printf(" M size %d \n",M.size());
M.insert(M.end(),SStars.begin(),SStars.end());
printf(" M size %d \n",M.size());
M.insert(M.end(),SkyF.begin(),SkyF.end());
printf(" M size %d \n",M.size());
F.Ngal=M.size();
//establish priority classes
init_time_at(time,"# establish priority clasess",t);
assign_priority_class(M);
std::vector <int> count_class(M.priority_list.size(),0);
for(int i;i<M.size();++i){
if(!M[i].SS&&!M[i].SF){
count_class[M[i].priority_class]+=1;
}
}
for(int i;i<M.priority_list.size();++i){
printf(" class %d number %d\n",i,count_class[i]);
}
print_time(time,"# ... took :");
// fiber positioners
PP pp;
pp.read_fiber_positions(F);
F.Nfiber = pp.fp.size()/2;
F.Npetal = max(pp.spectrom)+1;
F.Nfbp = (int) (F.Nfiber/F.Npetal);// fibers per petal = 500
pp.get_neighbors(F);
pp.compute_fibsofsp(F);
//P is original list of plates
Plates P = read_plate_centers(F);
F.Nplate=P.size();
printf(" full number of plates %d\n",F.Nplate);
printf("# Read %d plates from %s and %d fibers from %s\n",F.Nplate,F.tileFile.c_str(),F.Nfiber,F.fibFile.c_str());
// Computes geometries of cb and fh: pieces of positioner - used to determine possible collisions
F.cb = create_cb(); // cb=central body
F.fh = create_fh(); // fh=fiber holder
//// Collect available galaxies <-> tilefibers --------------------
// HTM Tree of galaxies
const double MinTreeSize = 0.01;
init_time_at(time,"# Start building HTM tree",t);
htmTree<struct target> T(M,MinTreeSize);
print_time(time,"# ... took :");//T.stats();
init_time_at(time,"# collect galaxies at ",t);
// For plates/fibers, collect available galaxies; done in parallel
collect_galaxies_for_all(M,T,P,pp,F);
print_time(time,"# ... took :");//T.stats();
init_time_at(time,"# collect available tile-fibers at",t);
// For each galaxy, computes available tilefibers G[i].av_tfs = [(j1,k1),(j2,k2),..]
collect_available_tilefibers(M,P,F);
//results_on_inputs("doc/figs/",G,P,F,true);
//// Assignment |||||||||||||||||||||||||||||||||||||||||||||||||||
printf(" Nplate %d Ngal %d Nfiber %d \n", F.Nplate, F.Ngal, F.Nfiber);
Assignment A(M,F);
print_time(t,"# Start assignment at : ");
std::cout.flush();
// Make a plan ----------------------------------------------------
// Plans whole survey without sky fibers, standard stars
// assumes maximum number of observations needed for QSOs, LRGs
simple_assign(M,P,pp,F,A);
//check to see if there are tiles with no galaxies
//need to keep mapping of old tile list to new tile list
//and inverse map
A.inv_order=initList(F.Nplate,-1);
int inv_count=0;
for (int j=0;j<F.Nplate ;++j){
bool not_done=true;
for(int k=0;k<F.Nfiber && not_done;++k){
if(A.TF[j][k]!=-1){
A.suborder.push_back(j);//suborder[jused] is jused-th used plate
not_done=false;
A.inv_order[j]=inv_count;//inv_order[j] is -1 unless used
inv_count++;
//and otherwise the position of plate j in list of used plates
}
}
}
F.NUsedplate=A.suborder.size();
printf(" Plates actually used %d \n",F.NUsedplate);
if(F.diagnose)diagnostic(M,Secret,F,A);
print_hist("Unused fibers",5,histogram(A.unused_fbp(pp,F),5),false); // Hist of unused fibs
// Smooth out distribution of free fibers, and increase the number of assignments
for (int i=0; i<1; i++) redistribute_tf(M,P,pp,F,A,0);// more iterations will improve performance slightly
for (int i=0; i<3; i++) {
improve(M,P,pp,F,A,0);
redistribute_tf(M,P,pp,F,A,0);
}
print_hist("Unused fibers",5,histogram(A.unused_fbp(pp,F),5),false);
//try assigning SF and SS before real time assignment
for (int jused=0;jused<F.NUsedplate;++jused){
int j=A.suborder[jused];
assign_sf_ss(j,M,P,pp,F,A); // Assign SS and SF for each tile
assign_unused(j,M,P,pp,F,A);
}
if(F.diagnose)diagnostic(M,Secret,F,A);
init_time_at(time,"# Begin real time assignment",t);
//Execute plan, updating targets at intervals
for(int i=0;i<F.pass_intervals.size();i++){
printf(" i=%d interval %d \n",i,F.pass_intervals[i]);
std::cout.flush();
}
std::vector <int> update_intervals=F.pass_intervals;
update_intervals.push_back(F.NUsedplate);//to end intervals at last plate
for(int i=0;i<update_intervals.size();++i){
printf("i %d update_interval %d\n",i, update_intervals[i]);
}
for(int i=0;i<update_intervals.size()-1;++i){//go plate by used plate
int starter=update_intervals[i];
//printf(" beginning at %d\n",starter);
//std::cout.flush();
for (int jused=starter; jused<update_intervals[i+1]; jused++) {
//printf(" jused %d\n",jused);
//std::cout.flush();
if (0<=jused-F.Analysis) {
update_plan_from_one_obs(jused,Secret,M,P,pp,F,A);
//printf(" 2 jused %d\n",jused);
//std::cout.flush();
}
else printf("\n no update\n");
// Update corrects all future occurrences of wrong QSOs etc and tries to observe something else
}
redistribute_tf(M,P,pp,F,A,starter);
improve(M,P,pp,F,A,starter);
redistribute_tf(M,P,pp,F,A,starter);
if(F.diagnose)diagnostic(M,Secret,F,A);
}
// check on SS and SF
List SS_hist=initList(11,0);
List SF_hist=initList(41,0);
for(int jused=0;jused<F.NUsedplate;++jused){
int j=A.suborder[jused];
for (int p=0;p<F.Npetal;++p){
int count_SS=0;
int count_SF=0;
for (int k=0;k<F.Nfbp;++k){
int kk=pp.fibers_of_sp[p][k];
int g=A.TF[j][kk];
if(g!=-1 && M[g].SS)count_SS++;
if(g!=-1 && M[g].SF)count_SF++;
}
SS_hist[count_SS]++;
SF_hist[count_SF]++;
}
}
printf(" SS distribution \n");
for(int i=0;i<10;i++)printf("%8d",SS_hist[i]);
printf("\n %8d \n",SS_hist[10]);
printf(" SF distribution \n");
for(int i=0;i<10;i++)printf("%8d",SF_hist[i]);
printf("\n");
for(int i=10;i<20;i++)printf("%8d",SF_hist[i]);
printf("\n");
for(int i=20;i<30;i++)printf("%8d",SF_hist[i]);
printf("\n");
for(int i=30;i<40;i++)printf("%8d",SF_hist[i]);
printf("\n %8d \n",SF_hist[40]);
// Results -------------------------------------------------------
if (F.PrintAscii) for (int jused=0; jused<F.NUsedplate; jused++){
write_FAtile_ascii(A.suborder[jused],F.outDir,M,P,pp,F,A);
}
if (F.PrintFits) for (int jused=0; jused<F.NUsedplate; jused++){
fa_write(A.suborder[jused],F.outDir,M,P,pp,F,A); // Write output
}
display_results("doc/figs/",Secret,M,P,pp,F,A,true);
if (F.Verif) A.verif(P,M,pp,F); // Verification that the assignment is sane
print_time(t,"# Finished !... in");
return(0);
}
/// Execute algorithm.
void Schrodinger1D::exec()
{
double startX = get("StartX");
double endX = get("EndX");
if (endX <= startX)
{
throw std::invalid_argument("StartX must be <= EndX");
}
IFunction_sptr VPot = getClass("VPot");
chebfun vpot( 0, startX, endX );
vpot.bestFit( *VPot );
size_t nBasis = vpot.n() + 1;
std::cerr << "n=" << nBasis << std::endl;
//if (n < 3)
{
nBasis = 200;
vpot.resize( nBasis );
}
const double beta = get("Beta");
auto kinet = new ChebCompositeOperator;
kinet->addRight( new ChebTimes(-beta) );
kinet->addRight( new ChebDiff2 );
auto hamiltonian = new ChebPlus;
hamiltonian->add('+', kinet );
hamiltonian->add('+', new ChebTimes(VPot) );
GSLMatrix L;
hamiltonian->createMatrix( vpot.getBase(), L );
GSLVector d;
GSLMatrix v;
L.diag( d, v );
std::vector<double> norms = vpot.baseNorm();
assert(norms.size() == L.size1());
assert(norms.size() == L.size2());
for(size_t i = 0; i < norms.size(); ++i)
{
double factor = 1.0 / norms[i];
for(size_t j = i; j < norms.size(); ++j)
{
v.multiplyBy(i,j,factor);
}
}
// eigenvectors orthogonality check
// GSLMatrix v1 = v;
// GSLMatrix tst;
// tst = Tr(v1) * v;
// std::cerr << tst << std::endl;
std::vector<size_t> indx(L.size1());
getSortedIndex( d, indx );
auto eigenvalues = API::TableWorkspace_ptr(dynamic_cast<API::TableWorkspace*>(
API::WorkspaceFactory::instance().create("TableWorkspace"))
);
eigenvalues->setRowCount(nBasis);
setProperty("Eigenvalues", eigenvalues);
eigenvalues->addColumn("double","N");
auto nColumn = static_cast<API::TableColumn<double>*>(eigenvalues->getColumn("N").get());
nColumn->asNumeric()->setPlotRole(API::NumericColumn::X);
auto& nc = nColumn->data();
eigenvalues->addDoubleColumn("Energy");
auto eColumn = static_cast<API::TableColumn<double>*>(eigenvalues->getColumn("Energy").get());
eColumn->asNumeric()->setPlotRole(API::NumericColumn::Y);
auto& ec = eigenvalues->getDoubleData("Energy");
boost::scoped_ptr<ChebfunVector> eigenvectors(new ChebfunVector);
chebfun fun0(nBasis,startX,endX);
ChebFunction_sptr theSum(new ChebFunction(fun0));
// collect indices of spurious eigenvalues to move them to the back
std::vector<size_t> spurious;
// index for good eigenvalues
size_t n = 0;
for(size_t j = 0; j < nBasis; ++j)
{
size_t i = indx[j];
chebfun fun(fun0);
fun.setP(v,i);
// check eigenvalues for spurious ones
chebfun dfun(fun);
dfun.square();
double norm = dfun.integr();
// I am not sure that it's a solid condition
if ( norm < 0.999999 )
{
// bad eigenvalue
spurious.push_back(j);
}
else
{
nc[n] = double(n);
ec[n] = d[i];
eigenvectors->add(ChebFunction_sptr(new ChebFunction(fun)));
// test sum of functions squares
*theSum += dfun;
// chebfun dfun(fun);
// hamiltonian->apply(fun,dfun);
// dfun *= fun;
// std::cerr << "ener["<<n<<"]=" << ec[n] << ' ' << norm << ' ' << dfun.integr() << std::endl;
++n;
}
}
GSLVector eigv;
ChebfunVector *eigf = NULL;
improve(hamiltonian, eigenvectors.get(), eigv, &eigf);
eigenvalues->setRowCount( eigv.size() );
for(size_t i = 0; i < eigv.size(); ++i)
{
nc[i] = double(i);
ec[i] = eigv[i];
}
eigf->add(theSum);
setProperty("Eigenvectors",ChebfunVector_sptr(eigf));
//makeQuadrature(eigf);
}
double square_root(double guess, double x)
{
while(good_enough(guess, x)==0)
guess = improve(guess, x);
return guess;
};
/**
* \brief Improve a candidate triangulation of poly by minimising
* the length of internal edges.
*
* @param [in] poly A vector containing the input polygon.
* @param [inout] result A vector of triangles, represented as
* indicies into poly. On input, this vector
* must contain a candidate triangulation of
* poly. Calling improve() modifies the
* contents of the vector, returning an
* improved triangulation.
*/
static inline void improve(const std::vector<carve::geom2d::P2> &poly, std::vector<tri_idx> &result, double EPSILON, double EPSILON2) {
improve(carve::geom2d::p2_adapt_ident(), poly, result, EPSILON, EPSILON2);
}
int main(int argc, char *argv[]){
int maxTotal;
int numCorners,numBorders,numCenters;
int perc_shake_border=0;
int perc_shake_center=0;
int perc_shake_coner=0;
int width;
int heigth;
int corners [4];
int *borders;
int *centers;
pos_t pos_corners[4];
pos_t *pos_borders;
pos_t *pos_centers;
int currBestScore=0,bestScore=BEST_SCORE;
int fine=0;
int p=1;
int levelMax=LEVEL_MAX;
int stepStarts=0;
int iterMax = ITER_MAX;
clock_t start,stop;
float difference;
switch(argc){
case 5:
if ( argv[1][1] == 't')
sscanf(argv[2],"%d", &maxTime);
else if ( argv[1][1] == 'p')
sscanf(argv[2],"%d", &maxScore);
else{
printf("Option not valid\n");
goto error;
}
FILE_IN = strdup(argv[3]);
FILE_OUT = strdup(argv[4]);
break;
case 7:
if ( argv[1][1] == 't')
sscanf(argv[2],"%d", &maxTime);
else{
printf("Option not valid\n");
goto error;
}
if ( argv[3][1] == 'p')
sscanf(argv[4],"%d", &maxScore);
else{
printf("Option not valid\n");
goto error;
}
FILE_IN = strdup(argv[5]);
FILE_OUT = strdup(argv[6]);
break;
default:
error: printf("\nUSAGE: %s [-t <time in seconds>] [-p <maximum score>] <input file> <output file>\n",argv[0]);
return 0;
}
srand(time(NULL));
parser(corners,&borders,¢ers,&vector,&width,&heigth);
numCorners=4;
numBorders=2*(heigth-2)+2*(width-2);
numCenters=(heigth-2)*(width-2);
pos_borders= (pos_t *) malloc( numBorders*sizeof(pos_t) );
pos_centers= (pos_t*) malloc(numCenters*sizeof(pos_t));
init_positions(pos_corners,pos_borders,pos_centers,width,heigth);
maxTotal=heigth*(width-1)+width*(heigth-1);
printf("Max Total: %d\n",maxTotal);
elem_sol **currBest,**best;
currBest=allocaMatrix(width,heigth);
best=allocaMatrix(width,heigth);
elem_sol**neighborOfcurrBest;
neighborOfcurrBest=allocaMatrix(width,heigth);
globalTime=clock();
while (!fine){
stepStarts++;
start=clock();
stop=clock();
difference=(float)(stop-globalTime)/CLOCKS_PER_SEC;
printf("\nGlobal Time %.2f Start %d - global best %d\n",difference,stepStarts,bestScore);
//leggiFile(vector,currBest,width,heigth);
generateRandomSolution(currBest,vector,corners,borders,centers,width,heigth);
currBestScore=CheckMatchingEdgesSol(currBest,width,heigth);
//printGame(heigth, width, currBest);
//printf ("parto da %d \n", currBestScore);
p=LEVEL_MIN;
fine=improve(0,start,p,levelMax,iterMax,&currBestScore,&bestScore,currBest,width,heigth,pos_centers,pos_borders,pos_corners,
numCenters,numBorders,numCorners,perc_shake_coner,perc_shake_border,perc_shake_center,maxTotal,best,stepStarts,MAX_UGUALE);
//printGame(heigth, width, currBest);
if ( currBestScore > bestScore ){
storeSolution(best,currBest,width,heigth);
bestScore=currBestScore;
//stop = clock();
//difference = (stop - start)/CLOCKS_PER_SEC;
//printf ("\nBEST edges matching = %d \t tempo: %f\n", bestScore, difference);
//printGame(heigth, width,best);
printer(width,heigth,best);
}
}
freeThings(currBest, best, neighborOfcurrBest, pos_borders, pos_centers, borders, centers, vector, heigth);
return 0;
}
//reduce redistributes, updates 07/02/15 rnc
int main(int argc, char **argv) {
//// Initializations ---------------------------------------------
srand48(1234); // Make sure we have reproducability
check_args(argc);
Time t, time; // t for global, time for local
init_time(t);
Feat F;
MTL M;
// Read parameters file //
F.readInputFile(argv[1]);
printFile(argv[1]);
init_time_at(time,"# read target, SS, SF files",t);
MTL Targ=read_MTLfile(F.Targfile,F,0,0);
MTL SStars=read_MTLfile(F.SStarsfile,F,1,0);
MTL SkyF=read_MTLfile(F.SkyFfile,F,0,1);
print_time(time,"# ... took :");
//combine the three input files
M=Targ;
printf(" Target size %d \n",M.size());
M.insert(M.end(),SStars.begin(),SStars.end());
printf(" Standard Star size %d \n",M.size());
M.insert(M.end(),SkyF.begin(),SkyF.end());
printf(" Sky Fiber size %d \n",M.size());
F.Ngal = M.size();
assign_priority_class(M);
std::vector <int> count_class(M.priority_list.size(),0);
for(int i;i<M.size();++i){
if(!M[i].SS&&!M[i].SF){
count_class[M[i].priority_class]+=1;
}
}
for(int i;i<M.priority_list.size();++i){
printf(" class %d number %d\n",i,count_class[i]);
}
print_time(time,"# ... took :");
// fiber positioners
PP pp;
pp.read_fiber_positions(F);
F.Nfiber = pp.fp.size()/2;
F.Npetal = max(pp.spectrom)+1;
F.Nfbp = (int) (F.Nfiber/F.Npetal);// fibers per petal = 500
pp.get_neighbors(F);
pp.compute_fibsofsp(F);
//P is original list of plates
Plates P = read_plate_centers(F);
F.Nplate=P.size();
printf("# Read %s plate centers from %s and %d fibers from %s\n",f(F.Nplate).c_str(),F.tileFile.c_str(),F.Nfiber,F.fibFile.c_str());
// Computes geometries of cb and fh: pieces of positioner - used to determine possible collisions
F.cb = create_cb(); // cb=central body
F.fh = create_fh(); // fh=fiber holder
//// Collect available galaxies <-> tilefibers --------------------
// HTM Tree of galaxies
const double MinTreeSize = 0.01;
init_time_at(time,"# Start building HTM tree",t);
htmTree<struct target> T(M,MinTreeSize);
print_time(time,"# ... took :");//T.stats();
init_time_at(time,"# collect galaxies at ",t);
// For plates/fibers, collect available galaxies; done in parallel P[plate j].av_gal[k]=[g1,g2,..]
collect_galaxies_for_all(M,T,P,pp,F);
print_time(time,"# ... took :");//T.stats();
init_time_at(time,"# collect available tile-fibers at",t);
// For each galaxy, computes available tilefibers G[i].av_tfs = [(j1,k1),(j2,k2),..]
collect_available_tilefibers(M,P,F);
//results_on_inputs("doc/figs/",G,P,F,true);
//// Assignment |||||||||||||||||||||||||||||||||||||||||||||||||||
printf(" Nplate %d Ngal %d Nfiber %d \n", F.Nplate, F.Ngal, F.Nfiber);
Assignment A(M,F);
// Make a plan ----------------------------------------------------
print_time(t,"# Start assignment at : ");
simple_assign(M,P,pp,F,A);
//check to see if there are tiles with no galaxies
//need to keep mapping of old tile list to new tile list
//and inverse map
A.inv_order=initList(F.Nplate,-1);
int inv_count=0;
for (int j=0;j<F.Nplate ;++j){
bool not_done=true;
for(int k=0;k<F.Nfiber && not_done;++k){
if(A.TF[j][k]!=-1){
A.suborder.push_back(j);//suborder[jused] is jused-th used plate
not_done=false;
A.inv_order[j]=inv_count;//inv_order[j] is -1 unless used
inv_count++;
}
}
}
F.NUsedplate=A.suborder.size();
printf(" Plates actually used %d \n",F.NUsedplate);
//for(int i=0;i<F.NUsedplate;i++)printf(" jused %d j %d\n",i,A.suborder[i]);
print_hist("Unused fibers",5,histogram(A.unused_fbp(pp,F),5),false); // Hist of unused fibs
// Smooth out distribution of free fibers, and increase the number of assignments
for (int i=0; i<1; i++) redistribute_tf(M,P,pp,F,A,0);// more iterations will improve performance slightly
for (int i=0; i<3; i++) {
improve(M,P,pp,F,A,0);
redistribute_tf(M,P,pp,F,A,0);
}
init_time_at(time,"# assign SS and SF ",t);
print_hist("Unused fibers",5,histogram(A.unused_fbp(pp,F),5),false);
//try assigning SF and SS before real time assignment
for (int jused=0;jused<F.NUsedplate;++jused){
int j=A.suborder[jused];
assign_sf_ss(j,M,P,pp,F,A); // Assign SS and SF for each tile
assign_unused(j,M,P,pp,F,A);
}
// Results -------------------------------------------------------*/
std::vector <int> total_used_by_class(M.priority_list.size(),0);
int total_used_SS=0;
int total_used_SF=0;
for (int jused=0;jused<F.NUsedplate;++jused){
std::vector <int> used_by_class(M.priority_list.size(),0);
int used_SS=0;
int used_SF=0;
int j=A.suborder[jused];
for(int k=0;k<F.Nfiber;++k){
int g=A.TF[j][k];
if(g!=-1){
if(M[g].SS){
total_used_SS++;
used_SS++;
}
else if(M[g].SF){
used_SF++;
total_used_SF++;
}
else{
used_by_class[M[g].priority_class]++;
total_used_by_class[M[g].priority_class]++;
}
}
}
/* printf(" plate jused %5d j %5d SS %4d SF %4d",jused,j,used_SS,used_SF);
for (int pr=0;pr<M.priority_list.size();++pr){
printf(" class %2d %5d",pr,used_by_class[pr]);
}
printf("\n");
*/
}
init_time_at(time,"# count SS and SF ",t);
printf(" Totals SS %4d SF %4d",total_used_SS,total_used_SF);
std::cout.flush();
for (int pr=0;pr<M.priority_list.size();++pr){
printf(" class %2d %5d",pr,total_used_by_class[pr]);
std::cout.flush();
}
printf("\n");
init_time_at(time,"# print txt files ",t);
if (F.PrintAscii) for (int jused=0; jused<F.NUsedplate; jused++){
int j=A.suborder[jused];
write_FAtile_ascii(j,F.outDir,M,P,pp,F,A);
}
init_time_at(time,"# print fits files ",t);
if (F.PrintFits) for (int jused=0; jused<F.NUsedplate; jused++){
int j=A.suborder[jused];
fa_write(j,F.outDir,M,P,pp,F,A); // Write output
}
/*
display_results("doc/figs/",G,M,P,pp,F,A,true);
if (F.Verif) A.verif(P,M,pp,F); // Verification that the assignment is sane
*/
print_time(t,"# Finished !... in");
return(0);
}
