Exemple #1
0
static int load_history(void)
{
	if ((decomp(history_fn, &history, sizeof(history), 1) != 1) || (history.id != CURRENT_ID)) {
		memset(&history, 0, sizeof(history));
		
		history_v0_t v0;
		
		if ((decomp(history_fn, &v0, sizeof(v0), 1) != 1) || (v0.id != ID_V0)) {
			syslog(LOG_INFO, "Unable to load history, clearing...");
			history.id = CURRENT_ID;
			return 0;
		}
		else {
			// --- temp conversion ---

			// V0 -> V1
			history.id = CURRENT_ID;
			memcpy(history.daily, v0.daily, sizeof(history.daily));
			history.dailyp = v0.dailyp;
			memcpy(history.monthly, v0.monthly, sizeof(v0.monthly));	// v0 is just shorter
			history.monthlyp = v0.monthlyp;
		}
	}
	else {
		_dprintf("history loaded d=%d m=%d\n", history.dailyp, history.monthlyp);
	}

	return 1;
}
Exemple #2
0
static int load_history(const char *fname)
{
	history_t hist;

	_dprintf("%s: fname=%s\n", __FUNCTION__, fname);

	if ((decomp(fname, &hist, sizeof(hist), 1) != 1) || (hist.id != CURRENT_ID)) {
		history_v0_t v0;

		if ((decomp(fname, &v0, sizeof(v0), 1) != 1) || (v0.id != ID_V0)) {
			_dprintf("%s: load failed\n", __FUNCTION__);
			return 0;
		}
		else {
			// --- temp conversion ---
			clear_history();

			// V0 -> V1
			history.id = CURRENT_ID;
			memcpy(history.daily, v0.daily, sizeof(history.daily));
			history.dailyp = v0.dailyp;
			memcpy(history.monthly, v0.monthly, sizeof(v0.monthly));	// v0 is just shorter
			history.monthlyp = v0.monthlyp;
		}
	}
	else {
		memcpy(&history, &hist, sizeof(history));
	}

	_dprintf("%s: dailyp=%d monthlyp=%d\n", __FUNCTION__, history.dailyp, history.monthlyp);
	return 1;
}
bool
solvetest(const LinAlg::Matrix<real_type,n,n>& m,
          const LinAlg::Vector<real_type,n>& v)
{
  // compute a decomposition
  LinAlg::MatrixFactors<real_type,n,n,LinAlg::LUTag> decomp(m);

  // crude condition estimation
  real_type nrm = 0;
  real_type rnrm = 0;
  for (unsigned i = 0; i < rows(v); ++i) {
    nrm = max(nrm, norm1(m*Vector::unit(i, rows(v))));
    rnrm = max(rnrm, norm1(decomp.solve(Vector::unit(i, rows(v)))));
  }
  real_type cond = nrm*rnrm;

  // determine allowed tolerance from the condition number
  real_type rtol = sqrt(rows(v))*cond*10*Limits<real_type>::epsilon();
  real_type atol = sqrt(rows(v))*1e-5*Limits<real_type>::epsilon();

  // Check ...
  if (!equal(v, decomp.solve(m*v), rtol, atol)) {
    std::cerr << "Matrix solve test failed\n";
    std::cerr << "   condition number:       " << cond << "\n";
    std::cerr << "   norm of the difference: "
              << norm(v - decomp.solve(m*v)) << std::endl;
    return false;
  }

  return true;
}
python::object RGroupDecomp(python::object cores,
                            python::object mols,
                            bool asSmiles = false,
                            bool asRows = true,
                            const RGroupDecompositionParameters &options = RGroupDecompositionParameters()
                            ) {
  RGroupDecompositionHelper decomp(cores, options);
  python::list unmatched;

  python::stl_input_iterator<ROMOL_SPTR> iter(mols), end;
  unsigned int idx=0;
  while (iter != end) {
    if (!*iter) throw_value_error("reaction called with None reactants");
    if(decomp.Add(*(*iter)) == -1) {
      unmatched.append(idx);
    }
    ++iter;
    ++idx;
  }

  decomp.Process();
  if ( asRows ) {
    return make_tuple(decomp.GetRGroupsAsRows(asSmiles), unmatched);
  } else {
    return make_tuple(decomp.GetRGroupsAsColumn(asSmiles), unmatched);
  }
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs [] ){
  int i, n = 0;
  int N, *pM, *pD; 
  double *pfM, *pfD;
  int nM, nD;

  if (nrhs != 2){
    mexErrMsgTxt("Usage: moddecomp n M.\n");
  }

  N  = (int)*(mxGetPr(prhs[0]));  
  nM = mxGetN(prhs[1]);
  pfM = mxGetPr(prhs[1]);
  
  pM = mxCalloc(nM, sizeof(int));
  for (i=0; i<nM; i++)
    pM[i] = (int)pfM[i];

  pD = mxCalloc(nM, sizeof(int));

  decomp(N, pM, pD, 0);

  plhs[0] = mxCreateDoubleMatrix(1, nM, mxREAL);
  pfD = mxGetPr(plhs[0]);
  for (i = 0; i<nM; i++)
    pfD[i] = (double)pD[i];

  mxFree(pM);
  mxFree(pD);

}
inline
void
GenEigsSolver<eT, SelectionRule, OpType>::retrieve_ritzpair()
  {
  arma_extra_debug_sigprint();
  
  UpperHessenbergEigen<eT> decomp(fac_H);
  
  Col< std::complex<eT> > evals = decomp.eigenvalues();
  Mat< std::complex<eT> > evecs = decomp.eigenvectors();
  
  SortEigenvalue< std::complex<eT>, SelectionRule > sorting(evals.memptr(), evals.n_elem);
  std::vector<uword> ind = sorting.index();
  
  // Copy the ritz values and vectors to ritz_val and ritz_vec, respectively
  for(uword i = 0; i < ncv; i++)
    {
    ritz_val(i) = evals(ind[i]);
    ritz_est(i) = evecs(ncv - 1, ind[i]);
    }
  for(uword i = 0; i < nev; i++)
    {
    ritz_vec.col(i) = evecs.col(ind[i]);
    }
  }
void DLL_EXPORT decompress(char *oldExeName, int exeSection, int dataOffset, char *newExeName, char *compressDll)
{
    // decompress compressed dbpro exe
    void* (*decomp)(void*, int);
    FILE *oldExe = fopen(oldExeName, "rb"); //compressed exe
    FILE *newExe = fopen(newExeName, "wb"); //uncompressed exe
    HANDLE lib = LoadLibrary(compressDll);  //compress.dll from compressed exe
    SIZE_T decompSize;
    int dataSize;
    long time;
    float seconds;
    void *buffer;

    decomp = (void* (*)(void*, int)) GetProcAddress(lib, "decompress_block");

    //get compressed data size
    fseek(oldExe, 0, SEEK_END);
    dataSize = ftell(oldExe) - dataOffset;
    fseek(oldExe, 0, SEEK_SET);

    //write exe section
    buffer = malloc(exeSection);
    fread(buffer, exeSection, 1, oldExe);
    fwrite(buffer, exeSection, 1, newExe);
    free(buffer);

    //load compressed data into buffer;
    fseek(oldExe, dataOffset, SEEK_SET);
    buffer = malloc(dataSize);
    fread(buffer, dataSize, 1, oldExe);

    //decompress data
    time = GetTickCount();
    void *data = decomp(buffer, dataSize);
    time = GetTickCount() - time;
    seconds = time / 1000.0;
    free(buffer);
    data = GlobalLock((HGLOBAL) data);
    decompSize = GlobalSize((HGLOBAL) data);

    //write decompressed data
    fwrite(data, decompSize, 1, newExe);
    GlobalUnlock((HGLOBAL) data);

    //write extra data
    fwrite(extraData, 16, 1, newExe);
    //write exeSection size
    fwrite(&exeSection, 4, 1, newExe);

    //show decompression stats message box
    char msg[255];
    msg[0] = 0;
    sprintf(msg, "Decompress complete in %.2f seconds", seconds);
    MessageBox(GetActiveWindow(), msg, "dark_explorer", 0);

    FreeLibrary(lib);
    fclose(oldExe);
    fclose(newExe);
}
void decomp(int q, int *pM, int *pD, int n){
  int d, r;
  if (q > 0){
    d = pM[n];
    r = q % d;
    q = (q-r)/d;
    pD[n] = r;
    decomp(q,pM,pD,++n);
  }
}
Mat mapLogMat(const Mat& Crxy, config_SystemParameter *param){
	CV_Assert( Crxy.rows == param->numFeature && Crxy.cols == param->numFeature);
	
	SVD decomp(Crxy);
	cv::log(decomp.w,decomp.w);
	Mat W = decomp.w.diag(decomp.w);
	Mat logA = decomp.u*W*decomp.vt;
	
	return logA;	
}
Foam::labelList Foam::ptscotchDecomp::decompose
(
    const polyMesh& mesh,
    const pointField& points,
    const scalarField& pointWeights
)
{
    if (points.size() != mesh.nCells())
    {
        FatalErrorIn
        (
            "ptscotchDecomp::decompose(const pointField&, const scalarField&)"
        )
            << "Can use this decomposition method only for the whole mesh"
            << endl
            << "and supply one coordinate (cellCentre) for every cell." << endl
            << "The number of coordinates " << points.size() << endl
            << "The number of cells in the mesh " << mesh.nCells()
            << exit(FatalError);
    }

//    // For running sequential ...
//    if (Pstream::nProcs() <= 1)
//    {
//        return scotchDecomp(decompositionDict_, mesh_)
//            .decompose(points, pointWeights);
//    }

    // Make Metis CSR (Compressed Storage Format) storage
    //   adjncy      : contains neighbours (= edges in graph)
    //   xadj(celli) : start of information in adjncy for celli


    CompactListList<label> cellCells;
    calcCellCells(mesh, identity(mesh.nCells()), mesh.nCells(), cellCells);

    // Decompose using default weights
    List<int> finalDecomp;
    decomposeZeroDomains
    (
        mesh.time().path()/mesh.name(),
        cellCells.m(),
        cellCells.offsets(),
        pointWeights,
        finalDecomp
    );

    // Copy back to labelList
    labelList decomp(finalDecomp.size());
    forAll(decomp, i)
    {
        decomp[i] = finalDecomp[i];
    }
    return decomp;
}
Exemple #11
0
void EKF<X, Y, A, B, C, D>::update(G observation_func, H observation_jacobian, C observation, D noise_covariance) {
  X prev_state              = this->mean;
  Y prev_covariance         = this->covariance;
  e::Matrix3d jacobian      = observation_jacobian(prev_state);
  this->residual            = observation - observation_func(prev_state);
  this->residual_covariance = (jacobian * (prev_covariance * jacobian.transpose())) + noise_covariance;
  e::FullPivHouseholderQR<D> decomp(this->residual_covariance); // Should we do M-P pseudoinverse here instead?
  // e::ColPivHouseholderQR<D> decomp(this->residual_covariance); // Should we do M-P pseudoinverse here instead?
  e::Matrix3d inverse       = decomp.inverse();
  e::Matrix3d temp_gain     = (prev_covariance * (jacobian.transpose() * inverse));
  if (s::isfinite(temp_gain.norm())) this->gain = temp_gain; // TODO Fixes numerical instability, but this could be better.
  this->mean                = prev_state + (gain * this->residual);
  this->covariance          = (e::Matrix3d::Identity() - (gain * jacobian)) * prev_covariance;
};
Foam::labelList Foam::ptscotchDecomp::decompose
(
    const labelListList& globalCellCells,
    const pointField& cellCentres,
    const scalarField& cWeights
)
{
    if (cellCentres.size() != globalCellCells.size())
    {
        FatalErrorIn
        (
            "ptscotchDecomp::decompose(const pointField&, const labelListList&)"
        )   << "Inconsistent number of cells (" << globalCellCells.size()
            << ") and number of cell centres (" << cellCentres.size()
            << ")." << exit(FatalError);
    }

//    // For running sequential ...
//    if (Pstream::nProcs() <= 1)
//    {
//        return scotchDecomp(decompositionDict_, mesh)
//            .decompose(globalCellCells, cellCentres, cWeights);
//    }


    // Make Metis CSR (Compressed Storage Format) storage
    //   adjncy      : contains neighbours (= edges in graph)
    //   xadj(celli) : start of information in adjncy for celli

    CompactListList<label> cellCells(globalCellCells);

    // Decompose using weights
    List<int> finalDecomp;
    decomposeZeroDomains
    (
        "ptscotch",
        cellCells.m(),
        cellCells.offsets(),
        cWeights,
        finalDecomp
    );

    // Copy back to labelList
    labelList decomp(finalDecomp.size());
    forAll(decomp, i)
    {
        decomp[i] = finalDecomp[i];
    }
    return decomp;
}
Exemple #13
0
void
decomp(void)
{
	save();

	p2 = pop();
	p1 = pop();

	// is the entire expression constant?

	if (find(p1, p2) == 0) {
		push(p1);
		//push(p1);	// may need later for pushing both +a, -a
		//negate();
		restore();
		return;
	}

	// sum?

	if (isadd(p1)) {
		decomp_sum();
		restore();
		return;
	}

	// product?

	if (car(p1) == symbol(MULTIPLY)) {
		decomp_product();
		restore();
		return;
	}

	// naive decomp if not sum or product

	p3 = cdr(p1);
	while (iscons(p3)) {
		push(car(p3));
		push(p2);
		decomp();
		p3 = cdr(p3);
	}

	restore();
}
Exemple #14
0
void
eval_decomp(void)
{
	int h = tos;
	push(symbol(NIL));
	push(cadr(p1));
	eval();
	push(caddr(p1));
	eval();
	p1 = pop();
	if (p1 == symbol(NIL))
		guess();
	else
		push(p1);
	decomp();
	list(tos - h);
}
    /*! Run
      \brief Generates the WSPD
      \param Wsp Vector of WSPs storing the output
      \param num_threads Number of threads to use (requires OPENMP)
    */
    void run(std::vector<WSP<Point> > &Wsp, int num_threads=1)
    {
        int i;
        int tid=0;
        std::vector<size_type> Wsp_size;
        std::vector<std::vector<WSP<Point> > > wsp;
        wsp.resize(num_threads);
#ifdef _OPENMP
        omp_set_num_threads(num_threads);
        #pragma omp parallel private(i, tid) shared(wsp)
        {
            tid = omp_get_thread_num();
            #pragma omp for schedule(static)
#endif
            for(i=1; i < (int) cqtree.size()/2; ++i)
            {
                decomp(&cqtree[i],
                       wsp[tid]);
            }
#ifdef _OPENMP
            #pragma omp barrier
            #pragma omp single
            {
#endif
                Wsp_size.resize(num_threads);
                Wsp_size[0]=0;
                for(i=1; i < num_threads; ++i)
                {
                    Wsp_size[i] = wsp[i-1].size()+Wsp_size[i-1];
                }
                Wsp.resize(Wsp_size[i-1]+wsp[i-1].size());
#ifdef _OPENMP
            } //End single section
            #pragma omp for schedule(static,1)
#endif
            for(i=0; i < num_threads; ++i)
            {
                memcpy(&(Wsp[Wsp_size[i]]), &(wsp[i][0]),
                       sizeof(WSP<Point>)*wsp[i].size());
            }
#ifdef _OPENMP
        } //End parallel section
#endif
    };
Foam::labelList Foam::scotchDecomp::decompose
(
    const labelListList& globalCellCells,
    const pointField& cc,
    const scalarField& cWeights
)
{
    if (cc.size() != globalCellCells.size())
    {
        FatalErrorIn
        (
            "scotchDecomp::decompose"
            "(const labelListList&, const pointField&, const scalarField&)"
        )   << "Inconsistent number of cells (" << globalCellCells.size()
            << ") and number of cell centres (" << cc.size()
            << ")." << exit(FatalError);
    }


    // Make Metis CSR (Compressed Storage Format) storage
    //   adjncy      : contains neighbours (= edges in graph)
    //   xadj(celli) : start of information in adjncy for celli

    List<int> adjncy;
    List<int> xadj;
    calcCSR(globalCellCells, adjncy, xadj);

    // Decompose using weights
    List<int> finalDecomp;
    decompose(adjncy, xadj, cWeights, finalDecomp);

    // Copy back to labelList
    labelList decomp(finalDecomp.size());

    forAll(decomp, i)
    {
        decomp[i] = finalDecomp[i];
    }

    return decomp;
}
  /**
   * \fn tLUdcmp( double** mat , unsigned n )
   *
   * \brief Creates an instance of this object.
   *
   * \param mat A ( n x n ) matrix.
   * \param n The number of rows and columns of matrix mat.
   *
   */
  tLUdcmp::tLUdcmp(
		   double** mat,
		   unsigned n
		  )
  {
    m_nele = n;
    m_matA = allocate( m_nele ) ;

    for ( unsigned i = 0 ; i < m_nele ; i++ ) {
      for ( unsigned j = 0 ; j < m_nele ; j++ ) {
        m_matA[ i ][ j ] = mat[ i ][ j ] ;       
      }
    }

    m_perm.resize( m_nele ) ;
    m_sign = 1 ;

    decomp() ;

    return ;
  }
int main(int argc, char **argv){
  int i, N;
  int *pM, *pD, nM;
  
  N = (int)atof(argv[1]);

  nM = argc-2;

  pM = calloc(nM, sizeof(int));
  pD = calloc(nM, sizeof(int));

  for (i = 0; i<nM; i++)
    pM[i] = (int)atof(argv[i+2]);

  decomp(N, pM, pD, 0);

  free(pM);
  free(pD);

  return 0;
}
Exemple #19
0
Foam::labelList Foam::metisDecomp::decompose
(
    const pointField& points,
    const scalarField& pointWeights
)
{
    if (points.size() != mesh_.nCells())
    {
        FatalErrorIn
        (
            "metisDecomp::decompose(const pointField&,const scalarField&)"
        )   << "Can use this decomposition method only for the whole mesh"
            << endl
            << "and supply one coordinate (cellCentre) for every cell." << endl
            << "The number of coordinates " << points.size() << endl
            << "The number of cells in the mesh " << mesh_.nCells()
            << exit(FatalError);
    }

    List<int> adjncy;
    List<int> xadj;
    scotchDecomp::calcCSR
    (
        mesh_,
        adjncy,
        xadj
    );

    // Decompose using default weights
    List<int> finalDecomp;
    decompose(adjncy, xadj, pointWeights, finalDecomp);

    // Copy back to labelList
    labelList decomp(finalDecomp.size());
    forAll(decomp, i)
    {
        decomp[i] = finalDecomp[i];
    }
    return decomp;
}
Exemple #20
0
void testSingle(std::string const & s0)
{
	uint64_t const l0 = s0.size();
	libmaus2::autoarray::AutoArray<char> C(s0.size(),false);

	for ( uint64_t bs = 1; bs <= 16; ++bs )
		for ( uint64_t b_0 = 0; b_0 <= l0; ++b_0 )
			for ( uint64_t b_1 = 0; b_1 <= l0-b_0; ++b_1 )
			{
				std::ostringstream o_0;
				libmaus2::lz::ZlibCompressorObjectFactory scompfact;
				libmaus2::lz::SimpleCompressedOutputStream<std::ostream> lzout_0(o_0,scompfact,bs);
			
				lzout_0.write(s0.c_str(),b_0);
				std::pair<uint64_t,uint64_t> start_0 = lzout_0.getOffset();
				lzout_0.write(s0.c_str()+b_0,b_1);
				// std::pair<uint64_t,uint64_t> end_0 = 
					lzout_0.getOffset();
				lzout_0.write(s0.c_str()+b_0+b_1,s0.size()-(b_0+b_1));
				lzout_0.flush();
						
				std::string const u0 = s0.substr(b_0,b_1);
				
				std::istringstream i_0(o_0.str());
				libmaus2::lz::ZlibDecompressorObjectFactory decompfact;
				libmaus2::lz::SimpleCompressedInputStream<std::istream> decomp(i_0,decompfact,start_0);
				
				uint64_t j = 0;
				for ( uint64_t i = 0; i < u0.size(); ++i )
				{
					int const c = decomp.get();
					assert ( c == u0[j++] );
				}
				
				// uint64_t const r = 
					decomp.read(C.begin(),l0-(b_0+b_1));
				assert ( decomp.get() == std::istream::traits_type::eof() );
			}
}
Exemple #21
0
Foam::labelList Foam::scotchDecomp::decompose
(
    const pointField& points,
    const scalarField& pointWeights
)
{
    if (points.size() != mesh_.nCells())
    {
        FatalErrorIn
        (
            "scotchDecomp::decompose(const pointField&, const scalarField&)"
        )
            << "Can use this decomposition method only for the whole mesh"
            << endl
            << "and supply one coordinate (cellCentre) for every cell." << endl
            << "The number of coordinates " << points.size() << endl
            << "The number of cells in the mesh " << mesh_.nCells()
            << exit(FatalError);
    }

    // Make Metis CSR (Compressed Storage Format) storage
    //   adjncy      : contains neighbours (= edges in graph)
    //   xadj(celli) : start of information in adjncy for celli
    List<int> adjncy;
    List<int> xadj;
    calcCSR(mesh_, adjncy, xadj);

    // Decompose using default weights
    List<int> finalDecomp;
    decompose(adjncy, xadj, pointWeights, finalDecomp);

    // Copy back to labelList
    labelList decomp(finalDecomp.size());
    forAll(decomp, i)
    {
        decomp[i] = finalDecomp[i];
    }
    return decomp;
}
  void MassDecompositionAlgorithm::getDecompositions(vector<MassDecomposition> & decomps, double mass)
  {
    double tolerance((double) param_.getValue("tolerance"));
    ims::RealMassDecomposer::decompositions_type decompositions = decomposer_->getDecompositions(mass, tolerance);

    for (ims::RealMassDecomposer::decompositions_type::const_iterator pos = decompositions.begin(); pos != decompositions.end(); ++pos)
    {
      String d;
      for (ims::IMSAlphabet::size_type i = 0; i < alphabet_->size(); ++i)
      {
        if ((*pos)[i] > 0)
        {
          d += alphabet_->getName(i) + String((*pos)[i]) + " ";
        }
      }
      d.trim();
      MassDecomposition decomp(d);
      decomps.push_back(decomp);
    }

    return;
  }
Exemple #23
0
void
decomp_product(void)
{
	int h;

	// decomp factors involving x

	p3 = cdr(p1);

	while (iscons(p3)) {
		if (find(car(p3), p2)) {
			push(car(p3));
			push(p2);
			decomp();
		}
		p3 = cdr(p3);
	}

	// multiply together all constant factors

	h = tos;

	p3 = cdr(p1);

	while (iscons(p3)) {
		if (find(car(p3), p2) == 0)
			push(car(p3));
		p3 = cdr(p3);
	}

	if (tos - h) {
		multiply_all(tos - h);
		//p3 = pop();	// may need later for pushing both +a, -a
		//push(p3);
		//push(p3);
		//negate();
	}
}
Exemple #24
0
void
decomp_sum(void)
{
	int h;

	// decomp terms involving x

	p3 = cdr(p1);

	while (iscons(p3)) {
		if (find(car(p3), p2)) {
			push(car(p3));
			push(p2);
			decomp();
		}
		p3 = cdr(p3);
	}

	// add together all constant terms

	h = tos;

	p3 = cdr(p1);

	while (iscons(p3)) {
		if (find(car(p3), p2) == 0)
			push(car(p3));
		p3 = cdr(p3);
	}

	if (tos - h) {
		add_all(tos - h);
		p3 = pop();
		push(p3);
		push(p3);
		negate();	// need both +a, -a for some integrals
	}
}
Exemple #25
0
qryproc()
{
	register QTREE			*root;
	register QTREE			*q;
	register int			i;
	register int			mode;
	register int			result_num;
	register int			retr_uniq;
	extern long			AAccuread;
	extern long			AAccuwrite;
	extern long			AAccusread;
	extern int			derror();
	extern QTREE			*trbuild();
	extern QTREE			*readqry();

#	ifdef xDTM
	if (AAtTf(76, 1))
		timtrace(23, 0);
#	endif
#	ifdef xDTR1
	if (AAtTf(50, 0))
		AAccuread = AAccusread = AAccuwrite = 0;
#	endif

	/* initialize query buffer */
	initbuf(Qbuf, QBUFSIZ, QBUFFULL, derror);

	/* init various variables in decomp for start of this query */
	startdecomp();

	/* Read in query, range table and mode */
	root = readqry();
	mode = Qmode;

	/* Initialize relation descriptors */
	initdesc(mode);

	/* re-build the tree */
	root = trbuild(root);
	if (!root)
		derror(STACKFULL);


	/* locate pointers to QLEND and TREE nodes */
	for (q = root->right; q->sym.type != QLEND; q = q->right)
		continue;
	Qle = q;

	for (q = root->left; q->sym.type != TREE; q = q->left)
		continue;
	Tr = q;


	/* map the complete tree */
	mapvar(root, 0);

	/* set logical locks */
	lockit(root, Resultvar);

	/* If there is no result variable then this must be a retrieve to the terminal */
	Qry_mode = Resultvar < 0 ? (int) mdRETTERM : mode;

	/* if the mode is retrieve_unique, then make a result rel */
	retr_uniq = mode == (int) mdRET_UNI;
	if (retr_uniq)
	{
		mk_unique(root);
		mode = (int) mdRETR;
	}

	/* get id of result relation */
	if (Resultvar < 0)
		result_num = NORESULT;
	else
		result_num = Rangev[Resultvar].relnum;

	/* evaluate aggregates in query */
	aggregate(root);

	/* decompose and process aggregate free query */
	decomp(root, mode, result_num);

	/* If this is a retrieve unique, then retrieve results */
	if (retr_uniq)
		pr_unique(root, Resultvar);

	if (mode != (int) mdRETR)
		i = ACK;
	else
		i = NOACK;
	i = endovqp(i);

	/* call update processor if batch mode */
	if (i == UPDATE)
	{
		initp();
		call_dbu(mdUPDATE, -1);
	}


	/*
	** send eop back to parser to indicate completion
	** if UPDATE then return block comes from dbu else
	** return block comes from decomp
	*/
	writeback(i == UPDATE ? -1 : 1);

#	ifdef xDTM
	if(AAtTf(76, 1))
		timtrace(24, 0);
#	endif
#	ifdef xDTR1
	AAtTfp(50, 1, "DECOMP read %ld pages,%ld catalog pages,wrote %ld pages\n",
		AAccuread, AAccusread, AAccuwrite);
#	endif

	/* clean decomp */
	reinit();

	/* return */
}
//void crosearch( int opt_value){
//float crosearch( int opt_value){
int crosearch(){

	
	// initialization
	currentPopSize = 1;		
	MoleColl= 0.9;
	initialKE = 1000; // the tolerance
	be = 50;// sprint
	be = 5;
	buffer =500;
	KElossRate = 0.5;
	al = 100000; //sprint
	al = 20000; //sprint
	//al = 10000; //sprint
	//al = 500000; //medium
	
	local_num = 0;
	generation_num = 500000000;
//	generation_num = 1;
	optiValueGlo= 0;

	//static FILE *decomp_fout = fopen("decomp_show.txt", "w+");




	struct Molecule MoleculePop[popSizeMax] = {0}; // create a larger holder
	//char optiHolder[10][NURSE_NUM][DAY_NUM] = {0}; // for h distance
	//optiSolution[NURSE_NUM][DAY_NUM] = {0};



	// ================ initial every mole =================
 	for(int moleidx = 0; moleidx < currentPopSize; moleidx++)	// initalize the small size :10
 	{	initMole(&MoleculePop[moleidx]);
 		//solutionShow(MoleculePop[moleidx].mole);
 		printf("\n");
 	}
		




	memset(optiSolution, 0, sizeof(optiSolution));// reset opti



	// =================== search ===================
	int optiFit = 10000;
	int optiFitForLog = 10000;

	
	start = clock();  
	//for (int generationIndex = 0; generationIndex <0 ; generationIndex++){
	for (int generationIndex = 0; generationIndex < generation_num; generationIndex++){
	//for (int generationIndex = 0; generationIndex < 1; generationIndex++){
		
		
		double b = (double)rand()/RAND_MAX;
		if( b  > MoleColl || currentPopSize == 1){// =================== uni reaction ======================
			int selectedIdx = rand()% (currentPopSize);
					
			if (MoleculePop[selectedIdx].NumHit - MoleculePop[selectedIdx].MinHit > al	){	
 				
				//for(int moleidx = 0; moleidx < currentPopSize; moleidx++)	// initalize the small size :10
				//	resetEnergy(&MoleculePop[moleidx]);
				//solutionShow(MoleculePop[moleidx].mole);
				//printf("\n");
				
				
				//int holder = 1;
				decomp(selectedIdx, MoleculePop);
			
	


			}
 			else
 				onwall(selectedIdx, MoleculePop);
 		} 
		else{//=================== inter reaction ===================
			int selectedIdx1 = rand()% (currentPopSize);
			int selectedIdx2 = rand()% (currentPopSize);
			while ( selectedIdx2 == selectedIdx1 )
				selectedIdx2 = rand()% (currentPopSize);

#ifdef intell_change
			// use this condition to let this reaction as effective as the onwall 
			if(MoleculePop[selectedIdx1].NumHit - MoleculePop[selectedIdx1].MinHit > (al/100) ||
				MoleculePop[selectedIdx2].NumHit - MoleculePop[selectedIdx2].MinHit > (al/100)){
#endif			


#ifndef intell_change
			if(MoleculePop[selectedIdx1].KE <= be && MoleculePop[selectedIdx2].KE <= be){
#endif
			
				//if(MoleculePop[selectedIdx1].KE > be && MoleculePop[selectedIdx2].KE > be){
				//printf("KE are %d %d\n",MoleculePop[selectedIdx1].KE,MoleculePop[selectedIdx2].KE);
				//intcolli(selectedIdx1,selectedIdx2);
				//if(findMinEp() < 65)
					synthe(selectedIdx1,selectedIdx2, MoleculePop);
			}
			else
				intcolli(selectedIdx1,selectedIdx2,MoleculePop);
		}


		// logging the pop
		//if( findMinEp(MoleculePop) < optiFitForLog || currentPopSize >1){
		////if( findMinEp() < optiFitForLog ){
		//	//printf("what the \n");
		//	//showPop(MoleculePop);
		//	
		//	optiFitForLog = findMinEp(MoleculePop);
		//	if(currentPopSize >1){
		//		optiFitForLog = 10000;
		//	}
		//}


		optiValueGlo = findMinEp(MoleculePop);


		if (  findMinEp(MoleculePop) < optiFit ){
			optiFit =  findMinEp(MoleculePop);
			//printf("min is %d \n", optiFit);
			printf("min is %d buffer is %d wall %d decom %d syn %d int %d\n", optiFit,buffer,
				onwallNum,decompNum,synthNum,intcollNum);
			
			//showPenaltySpec();


			solCopy(optiSolution,MoleculePop[findMinIdx(MoleculePop)].MinStruct);
			solutionStandardOutputFile(optiSolution);

			//finish = clock();
			//duration = (double)(finish - start) / CLOCKS_PER_SEC;    
		
			
			//printf( "  %1.2f sec\n", duration );  


			// for evaluator test
			//if( optiFit == opt_value){
			//	//solutionOutput(optiSolution);
			//	printf("%d \n", evaluate(optiSolution));
			//	solutionRosterShowScreen(optiSolution);
			//	showPenaltySpec();
			//	solutionStandardOutputFile(optiSolution);
			//	
			//	finish = clock();
			//	duration = (double)(finish - start) / CLOCKS_PER_SEC;    
			//	printf( "%f seconds\n", duration );  
			//	
			//	printf("\n%s",instAttri.instanceName);
			//	return duration;
			//	break;
			//}
		}

		finish = clock();
		duration = (double)(finish - start) / CLOCKS_PER_SEC;    
		if ( duration >8.3){
			printf("min is %d \n", optiFit);
			return optiFit;
			//break;
		}

#ifdef debug_getchar
		//if( findMinEp(MoleculePop) < 80 ){
			getchar();
		//}
#endif

 		
	
	} // search of generations

	//fclose(decomp_fout);
	
}






void experiment(){

	char instance_name[200][30] = {	
		"holder", 
		"instance\\sprint01.txt","instance\\sprint02.txt","instance\\sprint03.txt","instance\\sprint04.txt",
		"instance\\sprint05.txt","instance\\sprint06.txt","instance\\sprint07.txt","instance\\sprint08.txt",
		"instance\\sprint09.txt","instance\\sprint10.txt",
		
		"instance\\sprint_late01.txt","instance\\sprint_late02.txt","instance\\sprint_late03.txt",
		"instance\\sprint_late04.txt","instance\\sprint_late05.txt","instance\\sprint_late06.txt",
		"instance\\sprint_late07.txt","instance\\sprint_late08.txt","instance\\sprint_late09.txt",
		"instance\\sprint_late10.txt",
		
		"instance\\sprint_hidden01.txt","instance\\sprint_hidden02.txt","instance\\sprint_hidden03.txt","instance\\sprint_hidden04.txt",
		"instance\\sprint_hidden05.txt",

		"instance\\medium01.txt","instance\\medium02.txt","instance\\medium03.txt","instance\\medium04.txt",
		"instance\\medium05.txt",

		"instance\\medium_late01.txt","instance\\medium_late02.txt","instance\\medium_late03.txt","instance\\medium_late04.txt",
		"instance\\medium_late05.txt",

		"instance\\medium_hidden01.txt","instance\\medium_hidden02.txt","instance\\medium_hidden03.txt","instance\\medium_hidden04.txt",
		"instance\\medium_hidden05.txt",
	};
 
	int opti_array[50] = {	0,
							56,58,51,59,58,54,56,56,55,52,		// sprint	1 ~ 10; difficult: #4,#7,#10 
							37,42,48,73,44,42,42,17,17,43,		// sprint late	11 ~ 20; easy:18,19, almost diff
							33,32,62,67,59,						// sprint hidden 21-25: tend to trap into the near-optimal
							240,240,236,237,303,	// medium 26 ~ 30
							158,18,29,35,107,		// medium late	31 ~ 35
							130,221,36,80,122,		// medium hidden	36 ~ 40
	};


	//float time_found = 0;


 	// single test
	int sprint_id = 13;
	Load(instance_name[sprint_id]);
	printf("value is %d", crosearch());
	getchar();



	//FILE *file_result = fopen("test_result.txt", "w+");

	//for (int instance_id = 1; instance_id <= 25; instance_id++){
	//	int run_num = 5;
	//	int max_value = 0;
	//	int min_value = 1000;
	//	float total_value = 0;
	//	//float avg_value = 0;

	//	Load(instance_name[instance_id]);

	//	for(int i = 0; i < run_num; i++){

	//		int t = crosearch();
	//		//printf("value is %d", t);
	//		if( t < min_value) min_value = t;
	//		if( t > max_value) max_value = t;
	//		total_value += t;
	//	}

	//	fprintf(file_result,"%s: opti %d max %d, min %d, avg %1.2f\n",instance_name[instance_id],
	//		opti_array[instance_id],max_value,min_value,total_value/run_num);

	//	//printf("%s: max %d, min %d, avg %1.2f\n",instance_name[instance_id],max_value,
	//	//	min_value,total_value/run_num);
	//}

	//
	//fclose(file_result);
	//getchar();





	
	// bat test
	
 	//int run_num = 20;
  //	float min_time = 100000;
  //	float max_time = 0;
  //	
  //	//FILE *experiment_fout = fopen("experiment.txt", "w");
  //	FILE *experiment_fout = fopen("test_dec_neigh_sp03_nurseShakingdecomp.txt", "w");
  //	
  //	for( int sprint_id = 3 ; sprint_id < 4 ; sprint_id++){
  //		
  //		time_found = 0;
  //		
  //		Load(instance_name[sprint_id]);			
  //
  //		for(int i = 0; i < run_num; i++){
  //			int t = crosearch(opti_array[sprint_id]);
  //			if( t < min_time) min_time = t;
  //			if( t > max_time) max_time = t;
  //			time_found += t;
  //		}
  //		//printf("mean is %f", time_found/time_test);
  //		fprintf(experiment_fout,"inst id is %s, run num is %d, mean time is %3.1f, min is %3.1f, max is %3.1f\n",
  //			instance_name[sprint_id],run_num,time_found/run_num, min_time, max_time);
  //	}
  //	fclose(experiment_fout);






}
Exemple #27
0
void test_solver(BfmSolver solver)
{

  g5dParams parms;

  int Ls=16;
  double M5=1.8;
  double mq=0.0001;
  double wilson_lo = 0.05;
  double wilson_hi = 6.8;
  double shamir_lo = 0.025;
  double shamir_hi = 1.7;
  double ht_scale=1.7;
  double hw_scale=1.0;

  if ( solver != DWF ) { 
    exit(0);
    Printf("Should be testing HtCayleyTanh aka DWF\n");
  }
  parms.pDWF(mq,M5,Ls);

  multi1d<LatticeColorMatrix> u(4);
  HotSt(u);
  //  ArchivGauge_t Header ; readArchiv(Header,u,"ckpoint_lat.3000");  

  multi1d<LatticeFermion> src(Ls);

/* Rudy calculate some eigenvectors */


  BfmWrapperParams BWP;
  BWP.BfmInverter = BfmInv_CG; 
  BWP.BfmMatrix   = BfmMat_M;
  BWP.BfmPrecision= Bfm64bit;
  BWP.MaxIter     = 10000;
  BWP.RsdTarget.resize(1);
  BWP.RsdTarget[0]= 1.0e-9;
  BWP.Delta = 1.0e-4;
  BWP.BAP = parms;
  BfmWrapper bfm(BWP);

    bfmarg bfma;
#if defined(QDP_USE_OMP_THREADS)
    bfma.Threads(omp_get_max_threads());
#else
    bfma.Threads(16);
#endif
    bfma.Verbose(0);

    //Physics parameters
    bfmActionParams *bfmap = (bfmActionParams *) &bfma;
    *bfmap = bfm.invParam.BAP;
    
    // Algorithm & code control
    bfma.time_report_iter=-100;
    bfma.max_iter     = bfm.invParam.MaxIter;
    bfma.residual     = toDouble(bfm.invParam.RsdTarget[0]);

  int lx = QDP::Layout::subgridLattSize()[0];
  int ly = QDP::Layout::subgridLattSize()[1];
  int lz = QDP::Layout::subgridLattSize()[2];
  int lt = QDP::Layout::subgridLattSize()[3];
    //Geometry
    bfma.node_latt[0] = lx;
    bfma.node_latt[1] = ly;
    bfma.node_latt[2] = lz;
    bfma.node_latt[3] = lt;
    
    multi1d<int> procs = QDP::Layout::logicalSize();
    for(int mu=0;mu<4;mu++){
      if (procs[mu]>1) bfma.local_comm[mu] = 0;
      else             bfma.local_comm[mu] = 1;
    }
    
    // Bfm object
    bfm_qdp<double> bfm_eig; 
    bfm_eig.init(bfma);

    //Gauge field import
    bfm_eig.importGauge(u);

    //Subspace
#define NumberGaussian (1)
  Fermion_t subspace[NumberGaussian];
  Fermion_t check;
  Fermion_t mp;
  Fermion_t mmp;
  Fermion_t tmp_t;
  check = bfm_eig.allocFermion();
     mp = bfm_eig.allocFermion();
    mmp = bfm_eig.allocFermion();
  tmp_t = bfm_eig.allocFermion();
  bfm_eig.importFermion(src,check,1);

  QDPIO::cout << "Ls = "<<Ls<<endl;
  for(int g=0;g<NumberGaussian;g++){
    for(int s=0;s<Ls;s++){
      gaussian(src[s]);
    }
    subspace[g]=bfm_eig.allocFermion();
    bfm_eig.importFermion(src,subspace[g],1); // Half parity gaussian
    if ( g==0) {
      bfm_eig.importFermion(src,check,1);
    }
    for(int s=0;s<Ls;s++){
      src[s]=zero;
    }
    bfm_eig.exportFermion(src,subspace[g],1);
    QDPIO::cout << "Subspace norm " << norm2(src)<<endl;
  }
  for(int s=0;s<Ls;s++){
    gaussian(src[s]);
  }
  QDPIO::cout << "Got here " << endl;

  //  Handle< LinearOperatorArray<T> > linop =GetLinOp(u, parms);
  int block[5];
  for(int i=0;i<5;i++) block[i]=4;

  QDPIO::cout << "Initialised dirac op"<<endl;
  BfmLittleDiracOperator ldop(Ls,NumberGaussian,block,subspace,&bfm_eig);

  int ns = ldop.SubspaceDimension();
  QDPIO::cout << "subspace dimension is "<< ns<<endl;
  ns = ldop.SubspaceLocalDimension();
  QDPIO::cout << "subspace dimension per node is "<< ns<<endl;

  std::vector<std::complex<double> > decomp(ns);
  ldop.ProjectToSubspace(check,decomp);
  if (QMP_is_primary_node()){
    FILE * fp = fopen("coeff.dat","w");
    for(int s=0;s<ns;s++){
      fprintf(fp,"coeff %d %le %le\n",s,real(decomp[s]),imag(decomp[s]));
    }
    fclose(fp);
  }
  for(int s=0;s<ns;s++){
    QDPIO::cout << "coeff "<<s<<" " << real(decomp[s]) << " " << imag(decomp[s])<<endl;
  }
  ldop.PromoteFromSubspace(decomp,mp);
  double n;
#pragma omp parallel 
  {
    omp_set_num_threads(bfm_eig.nthread);
#pragma omp for 
    for(int t=0;t<bfm_eig.nthread;t++) {
      bfm_eig.axpy(check,mp,check,-1);
      n = bfm_eig.norm(check);
    }
  }
  QDPIO::cout << "project/promote n2diff "<< n<<endl;
  QMP_barrier();

QDPIO::cout << "Computing little dirac matrix"<<endl;
  ldop.ComputeLittleMatrixColored();

  QDPIO::cout << "Done"<<endl;

  std::vector<std::complex<double> > Aphi(ns);
  //        phi^dag DdagD phi = |Dphi|^2 with phi a subspace vector
  //        should be equal to Project/Apply/Promote + inner product

#pragma omp parallel 
  {
#pragma omp for 
    for(int t=0;t<bfm_eig.nthread;t++) {
      bfm_eig.Mprec(subspace[0],mp,tmp_t,0);
    }
  }

  QDPIO::cout << "Applied BFM matrix "<<endl;

  double n2;
#pragma omp parallel 
  {
    omp_set_num_threads(bfm_eig.nthread);
#pragma omp for 
    for(int t=0;t<bfm_eig.nthread;t++) {
      n2 = bfm_eig.norm(mp);
    }
  }

  QDPIO::cout << "Applied BFM matrix "<<n2<<endl;

  ldop.ProjectToSubspace(subspace[0],decomp);
  QDPIO::cout << "Projected to subspace "<<endl;
  ldop.Apply(decomp,Aphi);
  QDPIO::cout << "Applied A "<<endl;
  ldop.PromoteFromSubspace(Aphi,check);
  QDPIO::cout << "Promoted "<<endl;

  complex<double> inn;
#pragma omp parallel 
  {
#pragma omp for 
    for(int t=0;t<bfm_eig.nthread;t++) {
      inn = bfm_eig.inner(subspace[0],check);
    }
  }

  QDPIO::cout << "phi^dag Ddag D phi check " << n2 << " " <<real(inn) << imag(inn) <<endl;

  std::vector<std::complex<double> > AinvAphi(ns);
  ldop.ProjectToSubspace(subspace[0],decomp);
  ldop.Apply(decomp,Aphi);
  for(int s=0;s<ns;s++){
    QDPIO::cout << "Aphi "<<s<<" " << real(Aphi[s]) <<" " << imag(Aphi[s])<<endl;
  }
  ldop.PromoteFromSubspace(Aphi,check);

#pragma omp parallel 
  {
#pragma omp for 
    for(int t=0;t<bfm_eig.nthread;t++) {
      bfm_eig.Mprec(subspace[0],mp,tmp_t,0);
      bfm_eig.Mprec(mp,mmp,tmp_t,1);
    }
  }
  ldop.ProjectToSubspace(mmp,decomp);
  ldop.PromoteFromSubspace(decomp,mmp);
#pragma omp parallel 
  {
#pragma omp for 
    for(int t=0;t<bfm_eig.nthread;t++) {
      bfm_eig.axpy(check,mmp,check,-1.0);
      n2 = bfm_eig.norm(check);
    }
  }
  QDPIO::cout << "PMdagMP check n2diff "<< n2<<endl;


  QMP_barrier();
  QDPIO::cout << "Applying inverse"<<endl;
  ldop.ApplyInverse(Aphi,AinvAphi);
  QMP_barrier();
  for(int s=0;s<ns;s++){
    QDPIO::cout << "AinvAphi "<<s<<" " << real(AinvAphi[s]) << " " << imag(AinvAphi[s])<<endl;
  }
  ldop.PromoteFromSubspace(AinvAphi,check);

#pragma omp parallel 
  {
#pragma omp for 
    for(int t=0;t<bfm_eig.nthread;t++) {
      bfm_eig.axpy(check,subspace[0],check,-1.0);
      n2 = bfm_eig.norm(check);
    }
  }
  QDPIO::cout << "AinvA check n2diff "<< n2<<endl;
  

}
Exemple #28
0
bool FakedSeeding::fitXProjection(PrSeedTrack * track)
{
  float mat[6];
  float rhs[3];
  //std::fill(rhs,rhs+3,0);
  std::vector<Hit> Hits = track->hits();

  for(int loop = 0;3>loop;++loop)
  {
    std::fill(mat,mat+6,0.);
    std::fill(rhs,rhs+3,0.);
    for( int i=0; i < Hits.size() ;i++ )
    {
      const float w =  Hits[i].w2();//squared
      //std::cout<<"W\t"<<w<<std::endl;
      const float dz = Hits[i].GetZ() - m_zReference;
      float deta = 0;
      deta = dz*dz*(1-m_dRatio*dz);
      Hit *hit = new Hit(Hits[i].GetX(),Hits[i].GetY(),Hits[i].GetZ());
      float dist = track->distance(hit);
      //always()<<"Loop \t"<<loop<<"\n Distance From Hit \t"<<dist<<endmsg;
      // if(loop>0)
      // dist = track.distance( *itH ); //try the effect
      mat[0]+= w     ;
      mat[1]+= w * dz;
      mat[2]+= w * dz * dz;
      mat[3]+= w * deta;
      mat[4]+= w * dz * deta;
      mat[5]+= w * deta * deta;
      //right hand side
      rhs[0]+= w * dist;
      rhs[1]+= w * dist * dz;
      rhs[2]+= w * dist * deta;
    }

    ROOT::Math::CholeskyDecomp<float,3> decomp(mat);
    if(!decomp)
    {
      //std::cout<<"Failed to decompose matrix"<<std::endl;
      return false;
    }
    decomp.Solve(rhs);
    track->updateParameters(rhs[0],rhs[1],rhs[2],0.,0.);
  }
  float chi2_track = 0.;
  float maxChi2 = 0.;
  float maxDistance = 0.;
  // int i = 0; unused
  //compute Chi2 of the fitted track and the single Hit chi2
  for ( int i=0;i<Hits.size(); i++)
  {
    Hit *hit = new Hit(Hits[i].GetX(),Hits[i].GetY(),Hits[i].GetZ());
    hit->SetW2(Hits[i].w2());

    float distance = track->distance(hit);
    float chi2_onHit = track->chi2( hit ); //\frac{dist^{2}}{\sigma^{2}}
    if (chi2_onHit>maxChi2)
    {
      maxChi2 = chi2_onHit;
    }
    track_distance->Fill(distance);
    track_pullHits->Fill(chi2_onHit);
    chi2_track += track->chi2( hit );
    track_pullHitsVsP->Fill(chi2_onHit,(float)P);
    // //All Hits in 3 sigma? to check externally too
  }
  float constanteC = (track->b() * m_zReference - track->a())/(track->c());
  //backward extrapolation
  float X0 = track->a() - track->b()*m_zReference +track->c()*m_ConstC;
  //track_chi2PerDoFVs
  track->setChi2(chi2_track,3);
  XBackProjVsChi2->Fill(track->chi2(),X0);

  track_chi2->Fill(track->chi2());
  track_chi2PerDoF->Fill(track->chi2()/(3.));
  //std::cout<<"Delta Chi2 (should be 0) \t"<<chi2_track-track->chi2()<<std::endl;
  //if(std::abs(maxDistance) < 2 && std::sqrt(maxChi2) < 4) return true;
  return true;
}
Exemple #29
0
void daily_bgc (bgc_struct BGCM, bgc_grid * grid, const double t, const double naddfrac, int first_balance)
{
    siteconst_struct *sitec;
    metvar_struct  *metv;
    co2control_struct *co2;
    ndepcontrol_struct *ndepctrl;
    control_struct *ctrl;
    epconst_struct *epc;
    epvar_struct   *epv;
    psn_struct     *psn_sun, *psn_shade;
    wstate_struct  *ws;
    wflux_struct   *wf;
    cstate_struct  *cs;
    cflux_struct   *cf;
    nstate_struct  *ns;
    nflux_struct   *nf;
    ntemp_struct   *nt;
    phenology_struct *phen;
    summary_struct *summary;
    struct tm      *timestamp;
    time_t         *rawtime;

    /* miscelaneous variables for program control in main */
    int             simyr, yday, metyr, metday;
    int             annual_alloc;
    int             outv;
    int             i, nmetdays;
    double          tair_avg, tdiff;
    int             dayout;

    double          daily_ndep, daily_nfix, ndep_scalar, ndep_diff, ndep;
    int             ind_simyr;

    sitec = &grid->sitec;
    metv = &grid->metv;
    co2 = &BGCM->co2;
    ndepctrl = &BGCM->ndepctrl;
    ctrl = &BGCM->ctrl;
    epc = &grid->epc;
    epv = &grid->epv;
    ws = &grid->ws;
    wf = &grid->wf;
    cs = &grid->cs;
    cf = &grid->cf;
    ns = &grid->ns;
    nf = &grid->nf;
    nt = &grid->nt;
    phen = &grid->phen;
    psn_sun = &grid->psn_sun;
    psn_shade = &grid->psn_shade;
    summary = &grid->summary;

    rawtime = (time_t *) malloc (sizeof (time_t));
    *rawtime = (int)t;
    timestamp = gmtime (rawtime);


    /* Get co2 and ndep */
    if (ctrl->spinup == 1)      /* Spinup mode */
    {
        metv->co2 = co2->co2ppm;
        daily_ndep = ndepctrl->ndep / 365.0;
        daily_nfix = ndepctrl->nfix / 365.0;
    }
    else                        /* Model mode */
    {
        /* atmospheric CO2 and Ndep handling */
        if (!(co2->varco2))
        {
            /* constant CO2, constant Ndep */
            metv->co2 = co2->co2ppm;
            daily_ndep = ndepctrl->ndep / 365.0;
            daily_nfix = ndepctrl->nfix / 365.0;
        }
        else
        {
            /* When varco2 = 1, use file for co2 */
            if (co2->varco2 == 1)
                metv->co2 = get_co2 (BGCM->Forcing[CO2_TS][0], t);
            if (metv->co2 < -999)
            {
                printf ("Error finding CO2 value on %4.4d-%2.2d-%2.2d\n", timestamp->tm_year + 1900, timestamp->tm_mon + 1, timestamp->tm_mday);
                exit (1);
            }

            /* When varco2 = 2, use the constant CO2 value, but can vary
             * Ndep */
            if (co2->varco2 == 2)
                metv->co2 = co2->co2ppm;

            if (ndepctrl->varndep == 0)
            {
                /* Increasing CO2, constant Ndep */
                daily_ndep = ndepctrl->ndep / 365.0;
                daily_nfix = ndepctrl->nfix / 365.0;
            }
            else
            {
                daily_ndep = get_ndep (BGCM->Forcing[NDEP_TS][0], t);
                daily_nfix = ndepctrl->nfix / 365.0;
                if (daily_ndep < -999)
                {
                    printf ("Error finding NDEP %4.4d-%2.2d-%2.2d\n", timestamp->tm_year + 1900, timestamp->tm_mon + 1, timestamp->tm_mday);
                    exit (1);
                }
                else
                {
                    daily_ndep = daily_ndep / 365.0;
                }
            }
        }
    }

    precision_control (ws, cs, ns);

    /* zero all the daily flux variables */
    make_zero_flux_struct (wf, cf, nf);

    /* phenology fluxes */
    phenology (epc, metv, phen, epv, cs, cf, ns, nf);

    /* test for the annual allocation day */
    if (phen->remdays_litfall == 1)
        annual_alloc = 1;
    else
        annual_alloc = 0;

    /* Calculate leaf area index, sun and shade fractions, and specific
     * leaf area for sun and shade canopy fractions, then calculate
     * canopy radiation interception and transmission */
    radtrans (cs, epc, metv, epv, sitec->sw_alb);

    /* update the ann max LAI for annual diagnostic output */
    if (epv->proj_lai > epv->ytd_maxplai)
        epv->ytd_maxplai = epv->proj_lai;

    /* soil water potential */
    epv->vwc = metv->swc;
    soilpsi (sitec, epv->vwc, &epv->psi);

    /* daily maintenance respiration */
    maint_resp (cs, ns, epc, metv, cf, epv);

    /* begin canopy bio-physical process simulation */
    if (cs->leafc && metv->dayl)
    {
        /* conductance */
        canopy_et (metv, epc, epv, wf);
    }
    /* Do photosynthesis only when it is part of the current growth season, as
     * defined by the remdays_curgrowth flag.  This keeps the occurrence of
     * new growth consistent with the treatment of litterfall and
     * allocation */

    //printf ("leafc %lf dormant %lf, dayl %lf, soilc = %lf\n", cs->leafc, epv->dormant_flag, metv->dayl, summary->soilc);

    if (cs->leafc && !epv->dormant_flag && metv->dayl)
        total_photosynthesis (metv, epc, epv, cf, psn_sun, psn_shade);
    else
        epv->assim_sun = epv->assim_shade = 0.0;

    nf->ndep_to_sminn = daily_ndep;
    nf->nfix_to_sminn = daily_nfix;

    /* daily litter and soil decomp and nitrogen fluxes */
    decomp (metv->tsoil, epc, epv, cs, cf, ns, nf, nt);


    /* Daily allocation gets called whether or not this is a current growth
     * day, because the competition between decomp immobilization fluxes and
     * plant growth N demand is resolved here.  On days with no growth, no
     * allocation occurs, but immobilization fluxes are updated normally */
    daily_allocation (cf, cs, nf, ns, epc, epv, nt, naddfrac, ctrl->spinup);

    /* reassess the annual turnover rates for livewood --> deadwood, and for
     * evergreen leaf and fine root litterfall. This happens once each year,
     * on the annual_alloc day (the last litterfall day) */
    if (annual_alloc)
        annual_rates (epc, epv);

    /* daily growth respiration */
    growth_resp (epc, cf);

    /* daily update of carbon state variables */
    daily_carbon_state_update (cf, cs, annual_alloc, epc->woody, epc->evergreen);

    /* daily update of nitrogen state variables */
    daily_nitrogen_state_update (nf, ns, annual_alloc, epc->woody, epc->evergreen);

    /* Calculate N leaching loss.  This is a special state variable update
     * routine, done after the other fluxes and states are reconciled in order
     * to avoid negative sminn under heavy leaching potential */
    //nleaching(ns, nf, ws, wf);

    /* Calculate daily mortality fluxes and update state variables */
    /* This is done last, with a special state update procedure, to insure
     * that pools don't go negative due to mortality fluxes conflicting with
     * other proportional fluxes */
    mortality (epc, cs, cf, ns, nf);

    /* Test for carbon balance */
    check_carbon_balance (cs, &epv->old_c_balance, first_balance);

    /* Test for nitrogen balance */
    check_nitrogen_balance (ns, &epv->old_n_balance, first_balance);

    /* Calculate carbon summary variables */
    csummary (cf, cs, summary);
}
Exemple #30
-1
bool Compression::Decompression(void *src, unsigned int lenSrc, void *dst, unsigned int lenDst, bool bCheckVersion)
{
	if(bCheckVersion)
	{
		if(GameControl::Get()->GetGameFileVersion() < 19)
		{
			ind.ir(src, lenSrc);
			outd.iw(dst, lenDst);
			
			decomp();
		}
		else if(GameControl::Get()->GetGameFileVersion() < 20)
		{
			//Fast lzo decompression
			lzo1x_decompress((unsigned char *)src, lenSrc, (unsigned char *)dst, &lenDst, NULL);
		}
		else
		{
			//Ucl		
			if(!bUclOk) return false;	
			
			return ucl_nrv2b_decompress_8((const unsigned char *)src, lenSrc, (unsigned char *)dst, (unsigned int *)&lenDst, NULL) == UCL_E_OK;				
		}
	}
	else
	{
		//Ucl		
		if(!bUclOk) return false;		
		return ucl_nrv2b_decompress_8((const unsigned char *)src, lenSrc, (unsigned char *)dst, (unsigned int *)&lenDst, NULL) == UCL_E_OK;				
	}
	
	return true;
}